diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 3d59ec1b6..a0b3ec9d5 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -33,3 +33,4 @@ aee392a046a26ae2340849fe98e38332d9537397
 
 # new formatting style for improved readability
 0cccd586b8d75c64b289e38f334e95846dfb4f33
+72666721b5787c1adcc100dd86c26fbbe8bda82f
diff --git a/examples/benchmark/asio_thread_pool.cpp b/examples/benchmark/asio_thread_pool.cpp
index 3d6dae57b..ef693fe9f 100644
--- a/examples/benchmark/asio_thread_pool.cpp
+++ b/examples/benchmark/asio_thread_pool.cpp
@@ -18,7 +18,8 @@
 #include <exec/asio/asio_thread_pool.hpp>
 #include <exec/start_detached.hpp>
 
-struct RunThread {
+struct RunThread
+{
   void operator()(exec::asio::asio_thread_pool& pool,
                   std::size_t                   total_scheds,
                   std::size_t                   tid,
@@ -27,49 +28,62 @@ struct RunThread {
                   std::span<char> buffer,
 #endif
                   std::atomic<bool>& stop,
-                  exec::numa_policy  numa) {
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
-    auto scheduler = pool.get_scheduler();
-    std::mutex mut;
+    auto                    scheduler = pool.get_scheduler();
+    std::mutex              mut;
     std::condition_variable cv;
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource resource{
-        buffer.data(), buffer.size(), pmr::null_memory_resource()};
+      pmr::monotonic_buffer_resource   resource{buffer.data(),
+                                              buffer.size(),
+                                              pmr::null_memory_resource()};
       pmr::polymorphic_allocator<char> alloc(&resource);
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
-      while (scheds) {
-        exec::start_detached(
-          stdexec::schedule(scheduler) | stdexec::then([&] {
-            auto prev = counter.fetch_sub(1);
-            if (prev == 1) {
-              std::lock_guard lock{mut};
-              cv.notify_one();
-            }
-          }),
-          env);
+      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                               | stdexec::then(
+                                 [&]
+                                 {
+                                   auto prev = counter.fetch_sub(1);
+                                   if (prev == 1)
+                                   {
+                                     std::lock_guard lock{mut};
+                                     cv.notify_one();
+                                   }
+                                 }),
+                             env);
         --scheds;
       }
 #else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      while (scheds) {
-        exec::start_detached(stdexec::schedule(scheduler) | stdexec::then([&] {
-                                  auto prev = counter.fetch_sub(1);
-                                  if (prev == 1) {
-                                    std::lock_guard lock{mut};
-                                    cv.notify_one();
-                                  }
-                                }));
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                             | stdexec::then(
+                               [&]
+                               {
+                                 auto prev = counter.fetch_sub(1);
+                                 if (prev == 1)
+                                 {
+                                   std::lock_guard lock{mut};
+                                   cv.notify_one();
+                                 }
+                               }));
         --scheds;
       }
 #endif
@@ -81,6 +95,7 @@ struct RunThread {
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::asio::asio_thread_pool, RunThread>(argc, argv);
 }
diff --git a/examples/benchmark/fibonacci.cpp b/examples/benchmark/fibonacci.cpp
index 14fa101f7..c6be63ee9 100644
--- a/examples/benchmark/fibonacci.cpp
+++ b/examples/benchmark/fibonacci.cpp
@@ -24,7 +24,8 @@
 #include <exec/any_sender_of.hpp>
 #include <stdexec/execution.hpp>
 
-auto serial_fib(long n) -> long {
+auto serial_fib(long n) -> long
+{
   return n < 2 ? n : serial_fib(n - 1) + serial_fib(n - 2);
 }
 
@@ -35,41 +36,48 @@ using any_sender_of =
 using fib_sender = any_sender_of<stdexec::set_value_t(long)>;
 
 template <typename Scheduler>
-struct fib_s {
-  using sender_concept = stdexec::sender_t;
+struct fib_s
+{
+  using sender_concept        = stdexec::sender_t;
   using completion_signatures = stdexec::completion_signatures<stdexec::set_value_t(long)>;
 
-  long cutoff;
-  long n;
+  long      cutoff;
+  long      n;
   Scheduler sched;
 
   template <class Receiver>
-  struct operation {
-    Receiver rcvr_;
-    long cutoff;
-    long n;
+  struct operation
+  {
+    Receiver  rcvr_;
+    long      cutoff;
+    long      n;
     Scheduler sched;
 
-    void start() & noexcept {
-      if (n < cutoff) {
+    void start() & noexcept
+    {
+      if (n < cutoff)
+      {
         stdexec::set_value(static_cast<Receiver&&>(rcvr_), serial_fib(n));
-      } else {
-        auto mkchild = [&](long n) {
+      }
+      else
+      {
+        auto mkchild = [&](long n)
+        {
           return stdexec::starts_on(sched, fib_sender(fib_s{cutoff, n, sched}));
         };
 
         exec::start_detached(
           stdexec::when_all(mkchild(n - 1), mkchild(n - 2))
-          | stdexec::then([rcvr = static_cast<Receiver&&>(rcvr_)](long a, long b) mutable {
-              stdexec::set_value(static_cast<Receiver&&>(rcvr), a + b);
-            }));
+          | stdexec::then([rcvr = static_cast<Receiver&&>(rcvr_)](long a, long b) mutable
+                          { stdexec::set_value(static_cast<Receiver&&>(rcvr), a + b); }));
       }
     }
   };
 
   template <stdexec::receiver_of<completion_signatures> Receiver>
   [[nodiscard]]
-  auto connect(Receiver rcvr) const -> operation<Receiver> {
+  auto connect(Receiver rcvr) const -> operation<Receiver>
+  {
     return {static_cast<Receiver&&>(rcvr), cutoff, n, sched};
   }
 };
@@ -78,14 +86,17 @@ template <class Scheduler>
 fib_s(long cutoff, long n, Scheduler sched) -> fib_s<Scheduler>;
 
 template <typename duration, typename F>
-auto measure(F&& f) {
+auto measure(F&& f)
+{
   std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
   f();
   return std::chrono::duration_cast<duration>(std::chrono::steady_clock::now() - start).count();
 }
 
-auto main(int argc, char** argv) -> int {
-  if (argc < 5) {
+auto main(int argc, char** argv) -> int
+{
+  if (argc < 5)
+  {
     std::cerr << "Usage: example.benchmark.fibonacci cutoff n nruns {tbb|static}" << std::endl;
     return -1;
   }
@@ -93,29 +104,36 @@ auto main(int argc, char** argv) -> int {
   // skip 'warmup' iterations for performance measurements
   static constexpr size_t warmup = 1;
 
-  long cutoff = std::strtol(argv[1], nullptr, 10);
-  long n = std::strtol(argv[2], nullptr, 10);
-  std::size_t nruns = std::strtoul(argv[3], nullptr, 10);
+  long        cutoff = std::strtol(argv[1], nullptr, 10);
+  long        n      = std::strtol(argv[2], nullptr, 10);
+  std::size_t nruns  = std::strtoul(argv[3], nullptr, 10);
 
-  if (nruns <= warmup) {
+  if (nruns <= warmup)
+  {
     std::cerr << "nruns should be >= " << warmup << std::endl;
     return -1;
   }
 
   std::variant<exec::tbb::tbb_thread_pool, exec::static_thread_pool> pool;
 
-  if (argv[4] == std::string_view("tbb")) {
+  if (argv[4] == std::string_view("tbb"))
+  {
     pool.emplace<exec::tbb::tbb_thread_pool>(static_cast<int>(std::thread::hardware_concurrency()));
-  } else {
-    pool.emplace<exec::static_thread_pool>(
-      std::thread::hardware_concurrency(), exec::bwos_params{}, exec::get_numa_policy());
+  }
+  else
+  {
+    pool.emplace<exec::static_thread_pool>(std::thread::hardware_concurrency(),
+                                           exec::bwos_params{},
+                                           exec::get_numa_policy());
   }
 
   std::vector<unsigned long> times;
-  long result;
-  for (unsigned long i = 0; i < nruns; ++i) {
-    auto snd = std::visit(
-      [&](auto&& pool) { return fib_sender(fib_s{cutoff, n, pool.get_scheduler()}); }, pool);
+  long                       result;
+  for (unsigned long i = 0; i < nruns; ++i)
+  {
+    auto snd = std::visit([&](auto&& pool)
+                          { return fib_sender(fib_s{cutoff, n, pool.get_scheduler()}); },
+                          pool);
 
     auto time = measure<std::chrono::milliseconds>(
       [&] { std::tie(result) = stdexec::sync_wait(std::move(snd)).value(); });
diff --git a/examples/benchmark/static_thread_pool.cpp b/examples/benchmark/static_thread_pool.cpp
index 6eca77a0a..9ffbb2480 100644
--- a/examples/benchmark/static_thread_pool.cpp
+++ b/examples/benchmark/static_thread_pool.cpp
@@ -18,61 +18,74 @@
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
 
-struct RunThread {
-  void operator()(
-    exec::static_thread_pool& pool,
-    std::size_t total_scheds,
-    std::size_t tid,
-    std::barrier<>& barrier,
+struct RunThread
+{
+  void operator()(exec::static_thread_pool& pool,
+                  std::size_t               total_scheds,
+                  std::size_t               tid,
+                  std::barrier<>&           barrier,
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-    std::span<char> buffer,
+                  std::span<char> buffer,
 #endif
-    std::atomic<bool>& stop,
-    exec::numa_policy numa) {
+                  std::atomic<bool>& stop,
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
     exec::nodemask mask{};
     mask.set(static_cast<std::size_t>(numa_node));
-    auto scheduler = pool.get_constrained_scheduler(&mask);
-    std::mutex mut;
+    auto                    scheduler = pool.get_constrained_scheduler(&mask);
+    std::mutex              mut;
     std::condition_variable cv;
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource resource{
-        buffer.data(), buffer.size(), pmr::null_memory_resource()};
+      pmr::monotonic_buffer_resource   resource{buffer.data(),
+                                              buffer.size(),
+                                              pmr::null_memory_resource()};
       pmr::polymorphic_allocator<char> alloc(&resource);
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
-      while (scheds) {
-        exec::start_detached(
-          stdexec::schedule(scheduler) | stdexec::then([&] {
-            auto prev = counter.fetch_sub(1);
-            if (prev == 1) {
-              std::lock_guard lock{mut};
-              cv.notify_one();
-            }
-          }),
-          env);
+      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                               | stdexec::then(
+                                 [&]
+                                 {
+                                   auto prev = counter.fetch_sub(1);
+                                   if (prev == 1)
+                                   {
+                                     std::lock_guard lock{mut};
+                                     cv.notify_one();
+                                   }
+                                 }),
+                             env);
         --scheds;
       }
 #else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      while (scheds) {
-        exec::start_detached(stdexec::schedule(scheduler) | stdexec::then([&] {
-                                  auto prev = counter.fetch_sub(1);
-                                  if (prev == 1) {
-                                    std::lock_guard lock{mut};
-                                    cv.notify_one();
-                                  }
-                                }));
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                             | stdexec::then(
+                               [&]
+                               {
+                                 auto prev = counter.fetch_sub(1);
+                                 if (prev == 1)
+                                 {
+                                   std::lock_guard lock{mut};
+                                   cv.notify_one();
+                                 }
+                               }));
         --scheds;
       }
 #endif
@@ -84,14 +97,17 @@ struct RunThread {
   }
 };
 
-struct my_numa_distribution : public exec::default_numa_policy {
+struct my_numa_distribution : public exec::default_numa_policy
+{
   [[nodiscard]]
-  auto thread_index_to_node(std::size_t index) const noexcept -> int {
+  auto thread_index_to_node(std::size_t index) const noexcept -> int
+  {
     return exec::default_numa_policy::thread_index_to_node(2 * index);
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_numa_distribution numa{};
   my_main<exec::static_thread_pool, RunThread>(argc, argv, numa);
 }
\ No newline at end of file
diff --git a/examples/benchmark/static_thread_pool_bulk_enqueue.cpp b/examples/benchmark/static_thread_pool_bulk_enqueue.cpp
index 778cf04bd..297cd7e7d 100644
--- a/examples/benchmark/static_thread_pool_bulk_enqueue.cpp
+++ b/examples/benchmark/static_thread_pool_bulk_enqueue.cpp
@@ -21,34 +21,37 @@
 #  include <exec/sequence/ignore_all_values.hpp>
 #  include <ranges>
 
-struct RunThread {
-  void operator()(
-    exec::static_thread_pool& pool,
-    std::size_t total_scheds,
-    std::size_t tid,
-    std::barrier<>& barrier,
+struct RunThread
+{
+  void operator()(exec::static_thread_pool& pool,
+                  std::size_t               total_scheds,
+                  std::size_t               tid,
+                  std::barrier<>&           barrier,
 #  ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-    std::span<char> buffer,
+                  std::span<char> buffer,
 #  endif
-    std::atomic<bool>& stop,
-    exec::numa_policy numa) {
+                  std::atomic<bool>& stop,
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #  ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource rsrc{buffer.data(), buffer.size()};
+      pmr::monotonic_buffer_resource   rsrc{buffer.data(), buffer.size()};
       pmr::polymorphic_allocator<char> alloc{&rsrc};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
+      auto                             env = stdexec::prop{stdexec::get_allocator, alloc};
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      auto iterate = exec::schedule_all(pool, std::views::iota(start, end))
+      auto iterate      = exec::schedule_all(pool, std::views::iota(start, end))
                    | exec::ignore_all_values() | stdexec::write_env(env);
 #  else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      auto iterate = exec::schedule_all(pool, std::views::iota(start, end))
+      auto iterate      = exec::schedule_all(pool, std::views::iota(start, end))
                    | exec::ignore_all_values();
 #  endif
       stdexec::sync_wait(iterate);
@@ -57,18 +60,20 @@ struct RunThread {
   }
 };
 
-struct my_numa_distribution : public exec::default_numa_policy {
+struct my_numa_distribution : public exec::default_numa_policy
+{
   [[nodiscard]]
-  auto thread_index_to_node(std::size_t index) const noexcept -> int {
+  auto thread_index_to_node(std::size_t index) const noexcept -> int
+  {
     return exec::default_numa_policy::thread_index_to_node(2 * index);
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   exec::numa_policy numa{my_numa_distribution{}};
   my_main<exec::static_thread_pool, RunThread>(argc, argv, std::move(numa));
 }
 #else
-int main() {
-}
+int main() {}
 #endif
\ No newline at end of file
diff --git a/examples/benchmark/static_thread_pool_bulk_enqueue_nested.cpp b/examples/benchmark/static_thread_pool_bulk_enqueue_nested.cpp
index 2d3265587..b6927f816 100644
--- a/examples/benchmark/static_thread_pool_bulk_enqueue_nested.cpp
+++ b/examples/benchmark/static_thread_pool_bulk_enqueue_nested.cpp
@@ -21,35 +21,38 @@
 #  include <exec/sequence/ignore_all_values.hpp>
 #  include <ranges>
 
-struct RunThread {
-  void operator()(
-    exec::static_thread_pool& pool,
-    std::size_t total_scheds,
-    std::size_t tid,
-    std::barrier<>& barrier,
+struct RunThread
+{
+  void operator()(exec::static_thread_pool& pool,
+                  std::size_t               total_scheds,
+                  std::size_t               tid,
+                  std::barrier<>&           barrier,
 #  ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-    std::span<char> buffer,
+                  std::span<char> buffer,
 #  endif
-    std::atomic<bool>& stop,
-    exec::numa_policy numa) {
+                  std::atomic<bool>& stop,
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
     auto scheduler = pool.get_scheduler_on_thread(tid);
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #  ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource rsrc{buffer.data(), buffer.size()};
+      pmr::monotonic_buffer_resource   rsrc{buffer.data(), buffer.size()};
       pmr::polymorphic_allocator<char> alloc{&rsrc};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
+      auto                             env = stdexec::prop{stdexec::get_allocator, alloc};
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      auto iterate = exec::iterate(std::views::iota(start, end)) | exec::ignore_all_values()
+      auto iterate      = exec::iterate(std::views::iota(start, end)) | exec::ignore_all_values()
                    | stdexec::write_env(env);
 #  else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      auto iterate = exec::iterate(std::views::iota(start, end)) | exec::ignore_all_values();
+      auto iterate      = exec::iterate(std::views::iota(start, end)) | exec::ignore_all_values();
 #  endif
       stdexec::sync_wait(stdexec::starts_on(scheduler, iterate));
       barrier.arrive_and_wait();
@@ -57,10 +60,10 @@ struct RunThread {
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::static_thread_pool, RunThread>(argc, argv);
 }
 #else
-int main() {
-}
+int main() {}
 #endif
\ No newline at end of file
diff --git a/examples/benchmark/static_thread_pool_nested.cpp b/examples/benchmark/static_thread_pool_nested.cpp
index f4a7028a1..8e08218fb 100644
--- a/examples/benchmark/static_thread_pool_nested.cpp
+++ b/examples/benchmark/static_thread_pool_nested.cpp
@@ -18,68 +18,86 @@
 #include <exec/start_detached.hpp>
 #include <exec/static_thread_pool.hpp>
 
-struct RunThread {
-  void operator()(
-    exec::static_thread_pool& pool,
-    std::size_t total_scheds,
-    std::size_t tid,
-    std::barrier<>& barrier,
+struct RunThread
+{
+  void operator()(exec::static_thread_pool& pool,
+                  std::size_t               total_scheds,
+                  std::size_t               tid,
+                  std::barrier<>&           barrier,
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-    std::span<char> buffer,
+                  std::span<char> buffer,
 #endif
-    std::atomic<bool>& stop,
-    exec::numa_policy numa) {
+                  std::atomic<bool>& stop,
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
-    auto scheduler = pool.get_scheduler();
-    std::mutex mut;
+    auto                    scheduler = pool.get_scheduler();
+    std::mutex              mut;
     std::condition_variable cv;
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource resource{
-        buffer.data(), buffer.size(), pmr::null_memory_resource()};
+      pmr::monotonic_buffer_resource   resource{buffer.data(),
+                                              buffer.size(),
+                                              pmr::null_memory_resource()};
       pmr::polymorphic_allocator<char> alloc(&resource);
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
-      stdexec::sync_wait(stdexec::schedule(scheduler) | stdexec::then([&] {
-                           auto nested_scheduler = pool.get_scheduler();
-                           while (scheds) {
-                             exec::start_detached(
-                               stdexec::schedule(nested_scheduler) | stdexec::then([&] {
-                                 auto prev = counter.fetch_sub(1);
-                                 if (prev == 1) {
-                                   std::lock_guard lock{mut};
-                                   cv.notify_one();
-                                 }
-                               }),
-                               env);
-                             --scheds;
-                           }
-                         }));
+      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
+      stdexec::sync_wait(stdexec::schedule(scheduler)
+                         | stdexec::then(
+                           [&]
+                           {
+                             auto nested_scheduler = pool.get_scheduler();
+                             while (scheds)
+                             {
+                               exec::start_detached(stdexec::schedule(nested_scheduler)
+                                                      | stdexec::then(
+                                                        [&]
+                                                        {
+                                                          auto prev = counter.fetch_sub(1);
+                                                          if (prev == 1)
+                                                          {
+                                                            std::lock_guard lock{mut};
+                                                            cv.notify_one();
+                                                          }
+                                                        }),
+                                                    env);
+                               --scheds;
+                             }
+                           }));
 #else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      stdexec::sync_wait(stdexec::schedule(scheduler) | stdexec::then([&] {
-                           auto nested_scheduler = pool.get_scheduler();
-                           while (scheds) {
-                             exec::start_detached(
-                               stdexec::schedule(nested_scheduler) | stdexec::then([&] {
-                                 auto prev = counter.fetch_sub(1);
-                                 if (prev == 1) {
-                                   std::lock_guard lock{mut};
-                                   cv.notify_one();
-                                 }
-                               }));
-                             --scheds;
-                           }
-                         }));
+      stdexec::sync_wait(stdexec::schedule(scheduler)
+                         | stdexec::then(
+                           [&]
+                           {
+                             auto nested_scheduler = pool.get_scheduler();
+                             while (scheds)
+                             {
+                               exec::start_detached(stdexec::schedule(nested_scheduler)
+                                                    | stdexec::then(
+                                                      [&]
+                                                      {
+                                                        auto prev = counter.fetch_sub(1);
+                                                        if (prev == 1)
+                                                        {
+                                                          std::lock_guard lock{mut};
+                                                          cv.notify_one();
+                                                        }
+                                                      }));
+                               --scheds;
+                             }
+                           }));
 #endif
       std::unique_lock lock{mut};
       cv.wait(lock, [&] { return counter.load() == 0; });
@@ -89,6 +107,7 @@ struct RunThread {
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::static_thread_pool, RunThread>(argc, argv);
 }
\ No newline at end of file
diff --git a/examples/benchmark/taskflow_thread_pool.cpp b/examples/benchmark/taskflow_thread_pool.cpp
index 2c9ed9c58..10db91980 100644
--- a/examples/benchmark/taskflow_thread_pool.cpp
+++ b/examples/benchmark/taskflow_thread_pool.cpp
@@ -18,59 +18,72 @@
 #include <exec/start_detached.hpp>
 #include <exec/taskflow/taskflow_thread_pool.hpp>
 
-struct RunThread {
-  void operator()(
-    exec::taskflow::taskflow_thread_pool& pool,
-    std::size_t total_scheds,
-    std::size_t tid,
-    std::barrier<>& barrier,
+struct RunThread
+{
+  void operator()(exec::taskflow::taskflow_thread_pool& pool,
+                  std::size_t                           total_scheds,
+                  std::size_t                           tid,
+                  std::barrier<>&                       barrier,
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-    std::span<char> buffer,
+                  std::span<char> buffer,
 #endif
-    std::atomic<bool>& stop,
-    exec::numa_policy numa) {
+                  std::atomic<bool>& stop,
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
-    auto scheduler = pool.get_scheduler();
-    std::mutex mut;
+    auto                    scheduler = pool.get_scheduler();
+    std::mutex              mut;
     std::condition_variable cv;
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource resource{
-        buffer.data(), buffer.size(), pmr::null_memory_resource()};
+      pmr::monotonic_buffer_resource   resource{buffer.data(),
+                                              buffer.size(),
+                                              pmr::null_memory_resource()};
       pmr::polymorphic_allocator<char> alloc(&resource);
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
-      while (scheds) {
-        exec::start_detached(
-          stdexec::schedule(scheduler) | stdexec::then([&] {
-            auto prev = counter.fetch_sub(1);
-            if (prev == 1) {
-              std::lock_guard lock{mut};
-              cv.notify_one();
-            }
-          }),
-          env);
+      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                               | stdexec::then(
+                                 [&]
+                                 {
+                                   auto prev = counter.fetch_sub(1);
+                                   if (prev == 1)
+                                   {
+                                     std::lock_guard lock{mut};
+                                     cv.notify_one();
+                                   }
+                                 }),
+                             env);
         --scheds;
       }
 #else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      while (scheds) {
-        exec::start_detached(stdexec::schedule(scheduler) | stdexec::then([&] {
-                                  auto prev = counter.fetch_sub(1);
-                                  if (prev == 1) {
-                                    std::lock_guard lock{mut};
-                                    cv.notify_one();
-                                  }
-                                }));
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                             | stdexec::then(
+                               [&]
+                               {
+                                 auto prev = counter.fetch_sub(1);
+                                 if (prev == 1)
+                                 {
+                                   std::lock_guard lock{mut};
+                                   cv.notify_one();
+                                 }
+                               }));
         --scheds;
       }
 #endif
@@ -82,6 +95,7 @@ struct RunThread {
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::taskflow::taskflow_thread_pool, RunThread>(argc, argv);
 }
diff --git a/examples/benchmark/tbb_thread_pool.cpp b/examples/benchmark/tbb_thread_pool.cpp
index d9da9379c..1d3514ee5 100644
--- a/examples/benchmark/tbb_thread_pool.cpp
+++ b/examples/benchmark/tbb_thread_pool.cpp
@@ -18,7 +18,8 @@
 #include <exec/start_detached.hpp>
 #include <exec/tbb/tbb_thread_pool.hpp>
 
-struct RunThread {
+struct RunThread
+{
   void operator()(exec::tbb::tbb_thread_pool& pool,
                   std::size_t                 total_scheds,
                   std::size_t                 tid,
@@ -31,46 +32,58 @@ struct RunThread {
   {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
-    auto scheduler = pool.get_scheduler();
-    std::mutex mut;
+    auto                    scheduler = pool.get_scheduler();
+    std::mutex              mut;
     std::condition_variable cv;
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
 #ifndef STDEXEC_NO_MONOTONIC_BUFFER_RESOURCE
-      pmr::monotonic_buffer_resource resource{
-        buffer.data(), buffer.size(), pmr::null_memory_resource()};
+      pmr::monotonic_buffer_resource   resource{buffer.data(),
+                                              buffer.size(),
+                                              pmr::null_memory_resource()};
       pmr::polymorphic_allocator<char> alloc(&resource);
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      auto env = stdexec::prop{stdexec::get_allocator, alloc};
-      while (scheds) {
-        exec::start_detached(
-          stdexec::schedule(scheduler) | stdexec::then([&] {
-            auto prev = counter.fetch_sub(1);
-            if (prev == 1) {
-              std::lock_guard lock{mut};
-              cv.notify_one();
-            }
-          }),
-          env);
+      auto                     env = stdexec::prop{stdexec::get_allocator, alloc};
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                               | stdexec::then(
+                                 [&]
+                                 {
+                                   auto prev = counter.fetch_sub(1);
+                                   if (prev == 1)
+                                   {
+                                     std::lock_guard lock{mut};
+                                     cv.notify_one();
+                                   }
+                                 }),
+                             env);
         --scheds;
       }
 #else
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t              scheds = end - start;
       std::atomic<std::size_t> counter{scheds};
-      while (scheds) {
-        exec::start_detached(stdexec::schedule(scheduler) | stdexec::then([&] {
-                               auto prev = counter.fetch_sub(1);
-                               if (prev == 1) {
-                                 std::lock_guard lock{mut};
-                                 cv.notify_one();
-                               }
-                             }));
+      while (scheds)
+      {
+        exec::start_detached(stdexec::schedule(scheduler)
+                             | stdexec::then(
+                               [&]
+                               {
+                                 auto prev = counter.fetch_sub(1);
+                                 if (prev == 1)
+                                 {
+                                   std::lock_guard lock{mut};
+                                   cv.notify_one();
+                                 }
+                               }));
         --scheds;
       }
 #endif
@@ -82,6 +95,7 @@ struct RunThread {
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::tbb::tbb_thread_pool, RunThread>(argc, argv);
 }
diff --git a/examples/benchmark/tbb_thread_pool_nested.cpp b/examples/benchmark/tbb_thread_pool_nested.cpp
index a5257560b..b8e448668 100644
--- a/examples/benchmark/tbb_thread_pool_nested.cpp
+++ b/examples/benchmark/tbb_thread_pool_nested.cpp
@@ -19,7 +19,8 @@
 #include <exec/tbb/tbb_thread_pool.hpp>
 #include <tbb/task_group.h>
 
-struct RunThread {
+struct RunThread
+{
   void operator()(exec::tbb::tbb_thread_pool& pool,
                   std::size_t                 total_scheds,
                   std::size_t                 tid,
@@ -28,31 +29,41 @@ struct RunThread {
                   [[maybe_unused]] std::span<char> buffer,
 #endif
                   std::atomic<bool>& stop,
-                  exec::numa_policy  numa) {
+                  exec::numa_policy  numa)
+  {
     int numa_node = numa.thread_index_to_node(tid);
     numa.bind_to_node(numa_node);
     auto scheduler = pool.get_scheduler();
-    while (true) {
+    while (true)
+    {
       barrier.arrive_and_wait();
-      if (stop.load()) {
+      if (stop.load())
+      {
         break;
       }
       auto [start, end] = exec::_pool_::even_share(total_scheds, tid, pool.available_parallelism());
-      std::size_t scheds = end - start;
+      std::size_t     scheds = end - start;
       tbb::task_group tg{};
-      stdexec::sync_wait(stdexec::schedule(scheduler) | stdexec::then([&] {
-                           for (std::size_t i = 0; i < scheds; ++i) {
-                             tg.run([&] {
-                               // empty
-                             });
-                           }
-                         }));
+      stdexec::sync_wait(stdexec::schedule(scheduler)
+                         | stdexec::then(
+                           [&]
+                           {
+                             for (std::size_t i = 0; i < scheds; ++i)
+                             {
+                               tg.run(
+                                 [&]
+                                 {
+                                   // empty
+                                 });
+                             }
+                           }));
       tg.wait();
       barrier.arrive_and_wait();
     }
   }
 };
 
-auto main(int argc, char** argv) -> int {
+auto main(int argc, char** argv) -> int
+{
   my_main<exec::tbb::tbb_thread_pool, RunThread>(argc, argv);
 }
diff --git a/examples/hello_coro.cpp b/examples/hello_coro.cpp
index 2b0459850..2ece71037 100644
--- a/examples/hello_coro.cpp
+++ b/examples/hello_coro.cpp
@@ -24,36 +24,42 @@
 using namespace stdexec;
 
 template <sender S1, sender S2>
-auto async_answer(S1 s1, S2 s2) -> exec::task<int> {
+auto async_answer(S1 s1, S2 s2) -> exec::task<int>
+{
   // Senders are implicitly awaitable (in this coroutine type):
   co_await static_cast<S2&&>(s2);
   co_return co_await static_cast<S1&&>(s1);
 }
 
 template <sender S1, sender S2>
-auto async_answer2(S1 s1, S2 s2) -> exec::task<std::optional<int>> {
+auto async_answer2(S1 s1, S2 s2) -> exec::task<std::optional<int>>
+{
   co_return co_await stopped_as_optional(async_answer(s1, s2));
 }
 
 // tasks have an associated stop token
-auto async_stop_token() -> exec::task<std::optional<stdexec::inplace_stop_token>> {
+auto async_stop_token() -> exec::task<std::optional<stdexec::inplace_stop_token>>
+{
   co_return co_await stopped_as_optional(get_stop_token());
 }
 
-auto main() -> int {
-  STDEXEC_TRY {
+auto main() -> int
+{
+  STDEXEC_TRY
+  {
     // Awaitables are implicitly senders:
     auto [i] = stdexec::sync_wait(async_answer2(just(42), just())).value();
     std::cout << "The answer is " << i.value() << '\n';
   }
-  STDEXEC_CATCH(std::exception & e) {
+  STDEXEC_CATCH(std::exception & e)
+  {
     std::cerr << "error: " << e.what() << '\n';
   }
-  STDEXEC_CATCH_ALL {
+  STDEXEC_CATCH_ALL
+  {
     std::cerr << "unknown error\n";
   }
 }
 #else
-int main() {
-}
+int main() {}
 #endif
diff --git a/examples/hello_world.cpp b/examples/hello_world.cpp
index 16902916c..665e83fee 100644
--- a/examples/hello_world.cpp
+++ b/examples/hello_world.cpp
@@ -23,12 +23,13 @@
 using namespace stdexec;
 using stdexec::sync_wait;
 
-auto main() -> int {
-  exec::numa_policy numa{exec::no_numa_policy{}};
+auto main() -> int
+{
+  exec::numa_policy        numa{exec::no_numa_policy{}};
   exec::static_thread_pool ctx{8};
-  scheduler auto sch = ctx.get_scheduler(); // 1
+  scheduler auto           sch = ctx.get_scheduler();  // 1
 
-  sender auto begin = schedule(sch); // 2
+  sender auto begin = schedule(sch);  // 2
   sender auto hi_again = then(                                           // 3
     begin,                                                               // 3
     [] {                                                                 // 3
@@ -36,20 +37,25 @@ auto main() -> int {
       return 13;                                                         // 3
     });                                                                  // 3
 
-  sender auto add_42 = then(hi_again, [](int arg) { return arg + 42; }); // 4
-  auto [i] = sync_wait(std::move(add_42)).value();                       // 5
+  sender auto add_42 = then(hi_again, [](int arg) { return arg + 42; });  // 4
+  auto [i]           = sync_wait(std::move(add_42)).value();              // 5
   std::cout << "Result: " << i << std::endl;
 
   // Sync_wait provides a run_loop scheduler
   std::tuple<run_loop::scheduler> t = sync_wait(get_scheduler()).value();
   (void) t;
 
-  auto y = let_value(get_scheduler(), [](auto sched) {
-    return starts_on(sched, then(just(), [] {
-                       std::cout << "from run_loop\n";
-                       return 42;
-                     }));
-  });
+  auto y = let_value(get_scheduler(),
+                     [](auto sched)
+                     {
+                       return starts_on(sched,
+                                        then(just(),
+                                             []
+                                             {
+                                               std::cout << "from run_loop\n";
+                                               return 42;
+                                             }));
+                     });
   sync_wait(std::move(y));
 
   sync_wait(when_all(just(42), get_scheduler(), get_stop_token()));
diff --git a/examples/io_uring.cpp b/examples/io_uring.cpp
index 33c80216c..971a4d424 100644
--- a/examples/io_uring.cpp
+++ b/examples/io_uring.cpp
@@ -27,44 +27,40 @@
 
 #include <iostream>
 
-auto main() -> int {
+auto main() -> int
+{
   exec::io_uring_context context;
   exec::io_uring_context context2;
-  std::thread io_thread{[&] { context.run_until_stopped(); }};
-  std::thread io_thread2{[&] { context2.run_until_stopped(); }};
-  auto scheduler = context.get_scheduler();
-  auto scheduler2 = context2.get_scheduler();
+  std::thread            io_thread{[&] { context.run_until_stopped(); }};
+  std::thread            io_thread2{[&] { context2.run_until_stopped(); }};
+  auto                   scheduler  = context.get_scheduler();
+  auto                   scheduler2 = context2.get_scheduler();
   using namespace std::chrono_literals;
 
-  stdexec::sync_wait(
-    exec::when_any(
-      exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
-      exec::schedule_after(scheduler2, 2s) | stdexec::then([] { std::cout << "Hello, 2!\n"; })
-        | stdexec::upon_stopped([] { std::cout << "Hello, 2, stopped.\n"; })));
-
-  stdexec::sync_wait(
-    exec::when_any(
-      exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; })
-        | stdexec::upon_stopped([] { std::cout << "Hello, 1, stopped.\n"; }),
-      exec::schedule_after(scheduler2, 500ms) | stdexec::then([] { std::cout << "Hello, 2!\n"; })
-        | stdexec::upon_stopped([] { std::cout << "Hello, 2, stopped.\n"; })));
-
-  stdexec::sync_wait(
-    stdexec::when_all(
-      stdexec::schedule(scheduler) | stdexec::then([] { std::cout << "Hello, 0!\n"; }),
-      exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
-      exec::schedule_after(scheduler2, 2s) | stdexec::then([] { std::cout << "Hello, 2!\n"; }),
-      exec::schedule_after(scheduler, 3s) | stdexec::then([] { std::cout << "Stop it!\n"; }),
-      exec::finally(exec::schedule_after(scheduler2, 4s), stdexec::just() | stdexec::then([&] {
-                                                            context.request_stop();
-                                                          })),
-      exec::finally(exec::schedule_after(scheduler, 4s), stdexec::just() | stdexec::then([&] {
-                                                           context2.request_stop();
-                                                         })),
-      exec::schedule_after(scheduler, 10s) | stdexec::then([] { std::cout << "Hello, world!\n"; })
-        | stdexec::upon_stopped([] { std::cout << "Hello, stopped.\n"; }),
-      exec::schedule_after(scheduler2, 10s) | stdexec::then([] { std::cout << "Hello, world!\n"; })
-        | stdexec::upon_stopped([] { std::cout << "Hello, stopped.\n"; })));
+  stdexec::sync_wait(exec::when_any(
+    exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
+    exec::schedule_after(scheduler2, 2s) | stdexec::then([] { std::cout << "Hello, 2!\n"; })
+      | stdexec::upon_stopped([] { std::cout << "Hello, 2, stopped.\n"; })));
+
+  stdexec::sync_wait(exec::when_any(
+    exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; })
+      | stdexec::upon_stopped([] { std::cout << "Hello, 1, stopped.\n"; }),
+    exec::schedule_after(scheduler2, 500ms) | stdexec::then([] { std::cout << "Hello, 2!\n"; })
+      | stdexec::upon_stopped([] { std::cout << "Hello, 2, stopped.\n"; })));
+
+  stdexec::sync_wait(stdexec::when_all(
+    stdexec::schedule(scheduler) | stdexec::then([] { std::cout << "Hello, 0!\n"; }),
+    exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
+    exec::schedule_after(scheduler2, 2s) | stdexec::then([] { std::cout << "Hello, 2!\n"; }),
+    exec::schedule_after(scheduler, 3s) | stdexec::then([] { std::cout << "Stop it!\n"; }),
+    exec::finally(exec::schedule_after(scheduler2, 4s),
+                  stdexec::just() | stdexec::then([&] { context.request_stop(); })),
+    exec::finally(exec::schedule_after(scheduler, 4s),
+                  stdexec::just() | stdexec::then([&] { context2.request_stop(); })),
+    exec::schedule_after(scheduler, 10s) | stdexec::then([] { std::cout << "Hello, world!\n"; })
+      | stdexec::upon_stopped([] { std::cout << "Hello, stopped.\n"; }),
+    exec::schedule_after(scheduler2, 10s) | stdexec::then([] { std::cout << "Hello, world!\n"; })
+      | stdexec::upon_stopped([] { std::cout << "Hello, stopped.\n"; })));
   io_thread.join();
   io_thread2.join();
 
@@ -83,15 +79,14 @@ auto main() -> int {
 
   while (!context.is_running())
     ;
-  stdexec::sync_wait(
-    exec::when_any(
-      exec::schedule_after(scheduler, 1s) | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
-      exec::schedule_after(scheduler, 500ms) | stdexec::then([] { std::cout << "Hello, 2!\n"; })));
+  stdexec::sync_wait(exec::when_any(exec::schedule_after(scheduler, 1s)
+                                      | stdexec::then([] { std::cout << "Hello, 1!\n"; }),
+                                    exec::schedule_after(scheduler, 500ms)
+                                      | stdexec::then([] { std::cout << "Hello, 2!\n"; })));
 
   auto time_point = std::chrono::steady_clock::now() + 1s;
-  stdexec::sync_wait(exec::schedule_at(scheduler, time_point) | stdexec::then([] {
-                       std::cout << "Hello, schedule_at!\n";
-                     }));
+  stdexec::sync_wait(exec::schedule_at(scheduler, time_point)
+                     | stdexec::then([] { std::cout << "Hello, schedule_at!\n"; }));
 
   static_assert(exec::timed_scheduler<exec::io_uring_scheduler>);
 
diff --git a/examples/nvexec/maxwell_distributed.cu b/examples/nvexec/maxwell_distributed.cu
index 748b70f22..c3158f52f 100644
--- a/examples/nvexec/maxwell_distributed.cu
+++ b/examples/nvexec/maxwell_distributed.cu
@@ -306,31 +306,31 @@ namespace distributed
   };
 
   template <class AccessorT>
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   grid_initializer(float dt, AccessorT accessor) -> grid_initializer_t<AccessorT>
   {
     return {dt, accessor};
   }
 
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   right_nid(std::size_t cell_id, std::size_t col, std::size_t N) -> std::size_t
   {
     return col == N - 1 ? cell_id - (N - 1) : cell_id + 1;
   }
 
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   left_nid(std::size_t cell_id, std::size_t col, std::size_t N) -> std::size_t
   {
     return col == 0 ? cell_id + N - 1 : cell_id - 1;
   }
 
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   bottom_nid(std::size_t cell_id, std::size_t, std::size_t N) -> std::size_t
   {
     return cell_id - N;
   }
 
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   top_nid(std::size_t cell_id, std::size_t, std::size_t N) -> std::size_t
   {
     return cell_id + N;
@@ -359,7 +359,7 @@ namespace distributed
   };
 
   template <class AccessorT>
-  __host__ inline __device__ auto update_h(AccessorT accessor) -> h_field_calculator_t<AccessorT>
+  inline __host__ __device__ auto update_h(AccessorT accessor) -> h_field_calculator_t<AccessorT>
   {
     return {accessor};
   }
@@ -417,7 +417,7 @@ namespace distributed
   };
 
   template <class AccessorT>
-  __host__ inline __device__ auto
+  inline __host__ __device__ auto
   update_e(float *time, float dt, AccessorT accessor) -> e_field_calculator_t<AccessorT>
   {
     std::size_t source_position = accessor.n / 2 + (accessor.n * (accessor.n / 2));
diff --git a/examples/problem.cpp b/examples/problem.cpp
index c0811aa77..633885806 100644
--- a/examples/problem.cpp
+++ b/examples/problem.cpp
@@ -22,42 +22,43 @@
 
 namespace ex = stdexec;
 
-struct receiver_t {
+struct receiver_t
+{
   using receiver_concept = ex::receiver_t;
 
-  void set_value() && noexcept {
-  }
+  void set_value() && noexcept {}
 
   template <class... As>
-  void set_value(As...) && noexcept {
-  }
+  void set_value(As...) && noexcept
+  {}
 
   template <class Error>
-  void set_error(Error) && noexcept {
-  }
+  void set_error(Error) && noexcept
+  {}
 
-  void set_stopped() && noexcept {
-  }
+  void set_stopped() && noexcept {}
 };
 
 template <class Domain>
-void check_if_pool_domain() {
+void check_if_pool_domain()
+{
   using pool_domain = exec::_pool_::_static_thread_pool::domain;
   static_assert(std::is_same_v<Domain, pool_domain>);
 }
 
 template <class Domain>
-void check_if_inline_domain() {
+void check_if_inline_domain()
+{
   static_assert(std::is_same_v<Domain, ex::default_domain>);
 }
 
 template <class Sender, class Receiver>
-void check_if_starts_inline_and_completes_on_pool(Sender, Receiver) {
+void check_if_starts_inline_and_completes_on_pool(Sender, Receiver)
+{
   using receiver_env_t = ex::env_of_t<Receiver>;
 
   check_if_pool_domain<
-    ex::__detail::__completing_domain_t<ex::set_value_t, Sender, receiver_env_t>
-  >();
+    ex::__detail::__completing_domain_t<ex::set_value_t, Sender, receiver_env_t>>();
   check_if_inline_domain<ex::__detail::__starting_domain_t<receiver_env_t>>();
 
   // auto op_state = ex::connect(std::move(sender), std::move(receiver));
@@ -72,51 +73,59 @@ void print(T) {
 #endif
 
 template <class T, class Env = ex::env<>>
-struct expect_value_receiver_ex {
-  T dest_;
+struct expect_value_receiver_ex
+{
+  T   dest_;
   Env env_{};
 
   using receiver_concept = stdexec::receiver_t;
 
   explicit expect_value_receiver_ex(T dest)
-    : dest_(dest) {
-  }
+    : dest_(dest)
+  {}
 
   expect_value_receiver_ex(Env env, T dest)
     : dest_(dest)
-    , env_(std::move(env)) {
-  }
+    , env_(std::move(env))
+  {}
 
-  void set_value(T val) noexcept {
+  void set_value(T val) noexcept
+  {
     dest_ = val;
   }
 
   template <class... Ts>
-  void set_value(Ts...) noexcept {
+  void set_value(Ts...) noexcept
+  {
     std::cerr << "set_value called with wrong value types on expect_value_receiver_ex\n";
   }
 
-  void set_stopped() noexcept {
+  void set_stopped() noexcept
+  {
     std::cerr << "set_stopped called on expect_value_receiver_ex\n";
   }
 
-  void set_error(std::exception_ptr) noexcept {
+  void set_error(std::exception_ptr) noexcept
+  {
     std::cerr << "set_error called on expect_value_receiver_ex\n";
   }
 
-  auto get_env() const noexcept -> Env {
+  auto get_env() const noexcept -> Env
+  {
     return env_;
   }
 };
 
 template <ex::scheduler Sched = ex::inline_scheduler>
-inline auto _with_scheduler(Sched sched = {}) {
+inline auto _with_scheduler(Sched sched = {})
+{
   return ex::write_env(ex::prop{ex::get_scheduler, std::move(sched)});
 }
 
-int main() {
+int main()
+{
   exec::static_thread_pool pool(3);
-  auto sched = pool.get_scheduler();
+  auto                     sched = pool.get_scheduler();
 
   // check_if_starts_inline_and_completes_on_pool(ex::schedule(sched), receiver_t{});
   // check_if_starts_inline_and_completes_on_pool(ex::continues_on(ex::just(), sched), receiver_t{});
diff --git a/examples/retry.cpp b/examples/retry.cpp
index 552a3edac..dcbc2f265 100644
--- a/examples/retry.cpp
+++ b/examples/retry.cpp
@@ -22,23 +22,28 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Example code:
-struct fail_some {
+struct fail_some
+{
   using sender_concept = stdexec::sender_t;
-  using completion_signatures = stdexec::completion_signatures<
-    stdexec::set_value_t(int),
-    stdexec::set_error_t(std::exception_ptr)
-  >;
+  using completion_signatures =
+    stdexec::completion_signatures<stdexec::set_value_t(int),
+                                   stdexec::set_error_t(std::exception_ptr)>;
 
   template <class R>
-  struct op {
+  struct op
+  {
     R r_;
 
-    void start() & noexcept {
+    void start() & noexcept
+    {
       static int i = 0;
-      if (++i < 3) {
+      if (++i < 3)
+      {
         std::printf("fail!\n");
         stdexec::set_error(std::move(r_), std::exception_ptr{});
-      } else {
+      }
+      else
+      {
         std::printf("success!\n");
         stdexec::set_value(std::move(r_), 42);
       }
@@ -46,12 +51,14 @@ struct fail_some {
   };
 
   template <class R>
-  auto connect(R r) const -> op<R> {
+  auto connect(R r) const -> op<R>
+  {
     return {std::move(r)};
   }
 };
 
-auto main() -> int {
+auto main() -> int
+{
   auto x = retry(fail_some{});
   // prints:
   //   fail!
diff --git a/examples/scope.cpp b/examples/scope.cpp
index 299f262d7..8a166960c 100644
--- a/examples/scope.cpp
+++ b/examples/scope.cpp
@@ -27,34 +27,35 @@
 using namespace stdexec;
 using stdexec::sync_wait;
 
-struct noop_receiver {
+struct noop_receiver
+{
   using receiver_concept = receiver_t;
 
   template <class... _As>
-  void set_value(_As&&...) noexcept {
-  }
+  void set_value(_As&&...) noexcept
+  {}
 
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_error(std::exception_ptr) noexcept {}
 
-  void set_stopped() noexcept {
-  }
+  void set_stopped() noexcept {}
 
   [[nodiscard]]
-  auto get_env() const & noexcept {
+  auto get_env() const & noexcept
+  {
     return stdexec::prop{get_stop_token, stdexec::never_stop_token{}};
   }
 };
 
-auto main() -> int {
+auto main() -> int
+{
   exec::static_thread_pool ctx{1};
-  exec::async_scope scope;
+  exec::async_scope        scope;
 
-  scheduler auto sch = ctx.get_scheduler(); // 1
+  scheduler auto sch = ctx.get_scheduler();  // 1
 
-  sender auto begin = schedule(sch); // 2
+  sender auto begin = schedule(sch);  // 2
 
-  sender auto printVoid = then(begin, []() noexcept { printf("void\n"); }); // 3
+  sender auto printVoid = then(begin, []() noexcept { printf("void\n"); });  // 3
 
   sender auto printEmpty = then(
     starts_on(sch, scope.on_empty()),
@@ -62,25 +63,23 @@ auto main() -> int {
       printf("scope is empty\n");
     });
 
-  printf(
-    "\n"
-    "spawn void\n"
-    "==========\n");
+  printf("\n"
+         "spawn void\n"
+         "==========\n");
 
-  scope.spawn(printVoid); // 5
+  scope.spawn(printVoid);  // 5
 
   sync_wait(printEmpty);
 
-  printf(
-    "\n"
-    "spawn void and 42\n"
-    "=================\n");
+  printf("\n"
+         "spawn void and 42\n"
+         "=================\n");
 
-  sender auto fortyTwo = then(begin, []() noexcept { return 42; }); // 6
+  sender auto fortyTwo = then(begin, []() noexcept { return 42; });  // 6
 
-  scope.spawn(printVoid); // 7
+  scope.spawn(printVoid);  // 7
 
-  sender auto fortyTwoFuture = scope.spawn_future(fortyTwo); // 8
+  sender auto fortyTwoFuture = scope.spawn_future(fortyTwo);  // 8
 
   sender auto printFortyTwo = then(
     std::move(fortyTwoFuture),
@@ -88,10 +87,8 @@ auto main() -> int {
       printf("%d\n", fortyTwo);
     });
 
-  sender auto allDone =
-    then(when_all(printEmpty, std::move(printFortyTwo)), [](auto&&...) noexcept {
-      printf("\nall done\n");
-    }); // 10
+  sender auto allDone = then(when_all(printEmpty, std::move(printFortyTwo)),
+                             [](auto&&...) noexcept { printf("\nall done\n"); });  // 10
 
   sync_wait(std::move(allDone));
 
@@ -103,7 +100,7 @@ auto main() -> int {
 
   {
     sender auto nest = scope.nest(begin);
-    auto op = connect(std::move(nest), noop_receiver{});
+    auto        op   = connect(std::move(nest), noop_receiver{});
     (void) op;
   }
   sync_wait(scope.on_empty());
diff --git a/examples/server_theme/let_value.cpp b/examples/server_theme/let_value.cpp
index 3a53846bf..987c601fd 100644
--- a/examples/server_theme/let_value.cpp
+++ b/examples/server_theme/let_value.cpp
@@ -55,24 +55,27 @@
 #if !STDEXEC_NO_STD_EXCEPTIONS()
 namespace ex = stdexec;
 
-struct http_request {
-  std::string url_;
+struct http_request
+{
+  std::string                                      url_;
   std::vector<std::pair<std::string, std::string>> headers_;
-  std::string body_;
+  std::string                                      body_;
 };
 
-struct http_response {
-  int status_code_;
+struct http_response
+{
+  int         status_code_;
   std::string body_;
 };
 
 // Returns a sender that yields an http_request object for an incoming request
 template <ex::scheduler S>
-auto schedule_request_start(S sched, int idx) -> ex::sender auto {
+auto schedule_request_start(S sched, int idx) -> ex::sender auto
+{
   // app-specific-details: building of the http_request object
   auto url = std::string("/query?image_idx=") + std::to_string(idx);
   if (idx == 7)
-    url.clear(); // fake invalid request
+    url.clear();  // fake invalid request
   http_request req{.url_ = std::move(url), .headers_ = {}, .body_ = {}};
   std::cout << "HTTP request " << idx << " arrived\n";
 
@@ -81,14 +84,16 @@ auto schedule_request_start(S sched, int idx) -> ex::sender auto {
 }
 
 // Sends a response back to the client; yields a void signal on success
-auto send_response(const http_response& resp) -> ex::sender auto {
+auto send_response(http_response const & resp) -> ex::sender auto
+{
   std::cout << "Sending back response: " << resp.status_code_ << "\n";
   // Signal that we are done successfully
   return ex::just();
 }
 
 // Validate that the HTTP request is well-formed
-auto validate_request(const http_request& req) -> ex::sender auto {
+auto validate_request(http_request const & req) -> ex::sender auto
+{
   std::cout << "validating request " << req.url_ << "\n";
   if (req.url_.empty())
     throw std::invalid_argument("No URL");
@@ -96,37 +101,49 @@ auto validate_request(const http_request& req) -> ex::sender auto {
 }
 
 // Handle the request; main application logic
-auto handle_request(const http_request& req) -> ex::sender auto {
+auto handle_request(http_request const & req) -> ex::sender auto
+{
   std::cout << "handling request " << req.url_ << "\n";
   //...
   return ex::just(http_response{.status_code_ = 200, .body_ = "image details"});
 }
 
 // Transforms server errors into responses to be sent to the client
-auto error_to_response(std::exception_ptr err) -> ex::sender auto {
-  try {
+auto error_to_response(std::exception_ptr err) -> ex::sender auto
+{
+  try
+  {
     std::rethrow_exception(err);
-  } catch (const std::invalid_argument& e) {
+  }
+  catch (std::invalid_argument const & e)
+  {
     return ex::just(http_response{.status_code_ = 404, .body_ = e.what()});
-  } catch (const std::exception& e) {
+  }
+  catch (std::exception const & e)
+  {
     return ex::just(http_response{.status_code_ = 500, .body_ = e.what()});
-  } catch (...) {
+  }
+  catch (...)
+  {
     return ex::just(http_response{.status_code_ = 500, .body_ = "Unknown server error"});
   }
 }
 
 // Transforms cancellation of the server into responses to be sent to the client
-auto stopped_to_response() -> ex::sender auto {
+auto stopped_to_response() -> ex::sender auto
+{
   return ex::just(http_response{.status_code_ = 503, .body_ = "Service temporarily unavailable"});
 }
 
-auto main() -> int {
+auto main() -> int
+{
   // Create a thread pool and get a scheduler from it
   exec::static_thread_pool pool{8};
-  ex::scheduler auto sched = pool.get_scheduler();
+  ex::scheduler auto       sched = pool.get_scheduler();
 
   // Fake a couple of requests
-  for (int i = 0; i < 10; i++) {
+  for (int i = 0; i < 10; i++)
+  {
     // The whole flow for transforming incoming requests into responses
     ex::sender auto snd =
       // get a sender when a new request comes
@@ -155,8 +172,9 @@ auto main() -> int {
 
 #else
 
-int main() {
+int main()
+{
   std::cout << "This example requires C++ exceptions to be enabled.\n";
   return 0;
 }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
diff --git a/examples/server_theme/on_transfer.cpp b/examples/server_theme/on_transfer.cpp
index 698bb5ad2..995c23a54 100644
--- a/examples/server_theme/on_transfer.cpp
+++ b/examples/server_theme/on_transfer.cpp
@@ -47,22 +47,25 @@
 
 namespace ex = stdexec;
 
-struct sync_stream {
+struct sync_stream
+{
  private:
   static std::mutex s_mtx_;
 
  public:
-  std::ostream& sout_;
+  std::ostream&                sout_;
   std::unique_lock<std::mutex> lock_{s_mtx_};
 
   template <class T>
-  friend auto operator<<(sync_stream&& self, const T& value) -> sync_stream&& {
+  friend auto operator<<(sync_stream&& self, T const & value) -> sync_stream&&
+  {
     self.sout_ << value;
     return std::move(self);
   }
 
   friend auto
-    operator<<(sync_stream&& self, std::ostream& (*manip)(std::ostream&) ) -> sync_stream&& {
+  operator<<(sync_stream&& self, std::ostream& (*manip)(std::ostream&) ) -> sync_stream&&
+  {
     self.sout_ << manip;
     return std::move(self);
   }
@@ -70,35 +73,39 @@ struct sync_stream {
 
 std::mutex sync_stream::s_mtx_{};
 
-auto legacy_read_from_socket(int, char* buffer, size_t buffer_len) -> size_t {
-  const char fake_data[] = "Hello, world!";
-  size_t sz = sizeof(fake_data) - 1;
-  size_t count = (std::min) (sz, buffer_len);
+auto legacy_read_from_socket(int, char* buffer, size_t buffer_len) -> size_t
+{
+  char const fake_data[] = "Hello, world!";
+  size_t     sz          = sizeof(fake_data) - 1;
+  size_t     count       = (std::min) (sz, buffer_len);
   std::memcpy(buffer, fake_data, count);
   return count;
 }
 
-void process_read_data(const char* read_data, size_t read_len) {
+void process_read_data(char const * read_data, size_t read_len)
+{
   sync_stream{.sout_ = std::cout} << "Processing '" << std::string_view{read_data, read_len}
                                   << "'\n";
 }
 
-auto main() -> int {
+auto main() -> int
+{
   // Create a thread pool and get a scheduler from it
   exec::static_thread_pool work_pool{8};
-  ex::scheduler auto work_sched = work_pool.get_scheduler();
+  ex::scheduler auto       work_sched = work_pool.get_scheduler();
 
   exec::static_thread_pool io_pool{1};
-  ex::scheduler auto io_sched = io_pool.get_scheduler();
+  ex::scheduler auto       io_sched = io_pool.get_scheduler();
 
   std::array<std::byte, 16 * 1024> buffer;
 
   exec::async_scope scope;
 
   // Fake a couple of requests
-  for (int i = 0; i < 10; i++) {
-    int sock = i;
-    auto buf = reinterpret_cast<char*>(&buffer[0]);
+  for (int i = 0; i < 10; i++)
+  {
+    int  sock = i;
+    auto buf  = reinterpret_cast<char*>(&buffer[0]);
 
     // A sender that just calls the legacy read function
     auto snd_read = ex::just(sock, buf, buffer.size()) | ex::then(legacy_read_from_socket);
diff --git a/examples/server_theme/split_bulk.cpp b/examples/server_theme/split_bulk.cpp
index 71f1c5ce9..f363513f9 100644
--- a/examples/server_theme/split_bulk.cpp
+++ b/examples/server_theme/split_bulk.cpp
@@ -49,35 +49,44 @@
 
 namespace ex = stdexec;
 
-struct http_request {
-  std::string url_;
+struct http_request
+{
+  std::string                                      url_;
   std::vector<std::pair<std::string, std::string>> headers_;
-  std::string body_;
+  std::string                                      body_;
 };
 
-struct http_response {
-  int status_code_;
+struct http_response
+{
+  int         status_code_;
   std::string body_;
 };
 
-struct image {
+struct image
+{
   std::string image_data_;
 };
 
 // Extract the image from the HTTP request
-auto extract_image(http_request req) -> image {
+auto extract_image(http_request req) -> image
+{
   return {req.body_};
 }
 
 // Extract multiple images from the HTTP request
-auto extract_images(http_request req) -> std::vector<image> {
+auto extract_images(http_request req) -> std::vector<image>
+{
   std::vector<image> res;
-  size_t last_idx = 0;
-  while (last_idx >= std::string::npos) {
+  size_t             last_idx = 0;
+  while (last_idx >= std::string::npos)
+  {
     size_t idx = req.body_.find("\n", last_idx);
-    if (idx == std::string::npos) {
+    if (idx == std::string::npos)
+    {
       break;
-    } else {
+    }
+    else
+    {
       res.push_back(image{req.body_.substr(last_idx, idx - last_idx)});
       last_idx = idx + 1;
     }
@@ -88,41 +97,48 @@ auto extract_images(http_request req) -> std::vector<image> {
 }
 
 // Convert the given set of images into the corresponding HTTP response
-auto img3_to_response(const image& img1, const image& img2, const image& img3) -> http_response {
+auto img3_to_response(image const & img1, image const & img2, image const & img3) -> http_response
+{
   std::ostringstream oss;
   oss << img1.image_data_ << ", " << img2.image_data_ << ", " << img3.image_data_ << "\n";
   return {.status_code_ = 200, .body_ = oss.str()};
 }
 
 // Convert the given set of images into the corresponding HTTP response
-auto imgvec_to_response(const std::vector<image>& imgs) -> http_response {
+auto imgvec_to_response(std::vector<image> const & imgs) -> http_response
+{
   std::ostringstream oss;
-  for (const auto& img: imgs)
+  for (auto const & img: imgs)
     oss << img.image_data_ << "\n";
   return {.status_code_ = 200, .body_ = oss.str()};
 }
 
 // Apply the Canny edge detector on the given image
-auto apply_canny(const image& img) -> image {
+auto apply_canny(image const & img) -> image
+{
   return {"canny / " + img.image_data_};
 }
 
 // Apply the Sobel edge detector on the given image
-auto apply_sobel(const image& img) -> image {
+auto apply_sobel(image const & img) -> image
+{
   return {"sobel / " + img.image_data_};
 }
 
 // Apply the Prewitt edge detector on the given image
-auto apply_prewitt(const image& img) -> image {
+auto apply_prewitt(image const & img) -> image
+{
   return {"prewitt / " + img.image_data_};
 }
 
 // Apply blur filter on the given image
-auto apply_blur(const image& img) -> image {
+auto apply_blur(image const & img) -> image
+{
   return {"blur / " + img.image_data_};
 }
 
-auto handle_edge_detection_request(const http_request& req) -> ex::sender auto {
+auto handle_edge_detection_request(http_request const & req) -> ex::sender auto
+{
   // extract the input image from the request
   ex::sender auto in_img_sender = ex::just(req) | ex::then(extract_image);
 
@@ -132,31 +148,33 @@ auto handle_edge_detection_request(const http_request& req) -> ex::sender auto {
 
   // Apply the three methods of edge detection on the same input image, in parallel.
   // Then, join the results and generate the HTTP response
-  return ex::when_all(
-           multi_shot_img | ex::then(apply_canny),
-           multi_shot_img | ex::then(apply_sobel),
-           multi_shot_img | ex::then(apply_prewitt))
+  return ex::when_all(multi_shot_img | ex::then(apply_canny),
+                      multi_shot_img | ex::then(apply_sobel),
+                      multi_shot_img | ex::then(apply_prewitt))
        |
          // transform the resulting 3 images into an HTTP response
          ex::then(img3_to_response);
   // error and cancellation handling is performed outside
 }
 
-auto handle_multi_blur_request(const http_request& req) -> ex::sender auto {
+auto handle_multi_blur_request(http_request const & req) -> ex::sender auto
+{
   return
     // extract the input images from the request
     ex::just(req)
     | ex::then(extract_images)
     // process images in parallel with bulk.
     // use let_value to access the image count before calling bulk.
-    | ex::let_value([](std::vector<image> imgs) {
+    | ex::let_value(
+      [](std::vector<image> imgs)
+      {
         // get the image count
         size_t img_count = imgs.size();
         // return a sender that bulk-processes the image in parallel
         return ex::just(std::move(imgs))
-             | ex::bulk(ex::par, img_count, [](size_t i, std::vector<image>& imgs) {
-                 imgs[i] = apply_blur(imgs[i]);
-               });
+             | ex::bulk(ex::par,
+                        img_count,
+                        [](size_t i, std::vector<image>& imgs) { imgs[i] = apply_blur(imgs[i]); });
       })
     // transform the resulting 3 images into an HTTP response
     | ex::then(imgvec_to_response)
@@ -164,14 +182,16 @@ auto handle_multi_blur_request(const http_request& req) -> ex::sender auto {
     ;
 }
 
-auto main() -> int {
+auto main() -> int
+{
   // Create a thread pool and get a scheduler from it
   exec::static_thread_pool pool{8};
-  exec::async_scope scope;
-  ex::scheduler auto sched = pool.get_scheduler();
+  exec::async_scope        scope;
+  ex::scheduler auto       sched = pool.get_scheduler();
 
   // Fake a couple of edge_detect requests
-  for (int i = 0; i < 3; i++) {
+  for (int i = 0; i < 3; i++)
+  {
     // Create a test request
     http_request req{.url_ = "/edge_detect", .headers_ = {}, .body_ = "scene"};
 
@@ -179,17 +199,21 @@ auto main() -> int {
     ex::sender auto snd = handle_edge_detection_request(req);
 
     // Pack this into a simplified flow and execute it asynchronously
-    ex::sender auto action = std::move(snd) | ex::then([](http_response resp) {
-                               std::ostringstream oss;
-                               oss << "Sending response: " << resp.status_code_ << " / "
-                                   << resp.body_ << "\n";
-                               std::cout << oss.str();
-                             });
+    ex::sender auto action = std::move(snd)
+                           | ex::then(
+                               [](http_response resp)
+                               {
+                                 std::ostringstream oss;
+                                 oss << "Sending response: " << resp.status_code_ << " / "
+                                     << resp.body_ << "\n";
+                                 std::cout << oss.str();
+                               });
     scope.spawn(ex::starts_on(sched, std::move(action)));
   }
 
   // Fake a couple of multi_blur requests
-  for (int i = 0; i < 3; i++) {
+  for (int i = 0; i < 3; i++)
+  {
     // Create a test request
     http_request req{.url_ = "/multi_blur", .headers_ = {}, .body_ = "img1\nimg2\nimg3\nimg4\n"};
 
@@ -197,12 +221,15 @@ auto main() -> int {
     ex::sender auto snd = handle_multi_blur_request(req);
 
     // Pack this into a simplified flow and execute it asynchronously
-    ex::sender auto action = std::move(snd) | ex::then([](http_response resp) {
-                               std::ostringstream oss;
-                               oss << "Sending response: " << resp.status_code_ << " / "
-                                   << resp.body_ << "\n";
-                               std::cout << oss.str();
-                             });
+    ex::sender auto action = std::move(snd)
+                           | ex::then(
+                               [](http_response resp)
+                               {
+                                 std::ostringstream oss;
+                                 oss << "Sending response: " << resp.status_code_ << " / "
+                                     << resp.body_ << "\n";
+                                 std::cout << oss.str();
+                               });
     scope.spawn(ex::starts_on(sched, std::move(action)));
   }
 
diff --git a/examples/server_theme/then_upon.cpp b/examples/server_theme/then_upon.cpp
index 8ed76d279..3602ad60a 100644
--- a/examples/server_theme/then_upon.cpp
+++ b/examples/server_theme/then_upon.cpp
@@ -51,18 +51,21 @@
 
 namespace ex = stdexec;
 
-struct http_request {
-  std::string url_;
+struct http_request
+{
+  std::string                                      url_;
   std::vector<std::pair<std::string, std::string>> headers_;
-  std::string body_;
+  std::string                                      body_;
 };
 
-struct http_response {
-  int status_code_;
+struct http_response
+{
+  int         status_code_;
   std::string body_;
 };
 
-enum class obj_type {
+enum class obj_type
+{
   human,
   dog,
   cat,
@@ -72,8 +75,10 @@ enum class obj_type {
   cancelled,
 };
 
-auto as_string(obj_type t) -> const char* {
-  switch (t) {
+auto as_string(obj_type t) -> char const *
+{
+  switch (t)
+  {
   case obj_type::human:
     return "human";
   case obj_type::dog:
@@ -92,18 +97,21 @@ auto as_string(obj_type t) -> const char* {
   return "general error";
 }
 
-struct classification_result {
-  obj_type type_;
-  int accuracy_;
+struct classification_result
+{
+  obj_type    type_;
+  int         accuracy_;
   std::string details_{};
 };
 
-struct image {
+struct image
+{
   std::string image_data_;
 };
 
 // Extract the image from the HTTP request
-auto extract_image(http_request req) -> image {
+auto extract_image(http_request req) -> image
+{
   // TODO: make upon_error work before enabling this
   // if (req.body_.empty())
   //   throw std::invalid_argument("no image found");
@@ -111,7 +119,8 @@ auto extract_image(http_request req) -> image {
 }
 
 // Classify the image received
-auto do_classify(image img) -> classification_result {
+auto do_classify(image img) -> classification_result
+{
   if (img.image_data_ == "human")
     return {.type_ = obj_type::human, .accuracy_ = 93};
   else if (img.image_data_ == "cat")
@@ -124,24 +133,30 @@ auto do_classify(image img) -> classification_result {
 }
 
 // Check for errors and transform them into classification result
-auto on_classification_error(std::exception_ptr) -> classification_result {
+auto on_classification_error(std::exception_ptr) -> classification_result
+{
   return {.type_ = obj_type::general_error, .accuracy_ = 100, .details_ = {}};
 }
 
 // Check for cancellation and transform it into classification result
-auto on_classification_cancelled() -> classification_result {
+auto on_classification_cancelled() -> classification_result
+{
   return {.type_ = obj_type::cancelled, .accuracy_ = 100};
 }
 
 // Convert the classification result into an HTTP response
-auto to_response(classification_result res) -> http_response {
+auto to_response(classification_result res) -> http_response
+{
   if (res.type_ == obj_type::general_error)
     // Send a 500 response back if we have a general error
     return {.status_code_ = 500, .body_ = res.details_};
-  else if (res.type_ == obj_type::cancelled) {
+  else if (res.type_ == obj_type::cancelled)
+  {
     // Send a 503 response back if the computation is cancelled
     return {.status_code_ = 503, .body_ = "cancelled"};
-  } else {
+  }
+  else
+  {
     // Send a success response back, with the object type, accuracy and details
     std::ostringstream oss;
     oss << as_string(res.type_) << " (" << res.accuracy_ << ")\n" << res.details_;
@@ -150,7 +165,8 @@ auto to_response(classification_result res) -> http_response {
 }
 
 // Handler for the "classify" request type
-auto handle_classify_request(const http_request& req) -> ex::sender auto {
+auto handle_classify_request(http_request const & req) -> ex::sender auto
+{
   return
     // start with the input buffer
     ex::just(req)
@@ -169,16 +185,18 @@ auto handle_classify_request(const http_request& req) -> ex::sender auto {
     ;
 }
 
-auto main() -> int {
+auto main() -> int
+{
   // Create a thread pool and get a scheduler from it
-  exec::async_scope scope;
+  exec::async_scope        scope;
   exec::static_thread_pool pool{8};
-  ex::scheduler auto sched = pool.get_scheduler();
+  ex::scheduler auto       sched = pool.get_scheduler();
 
   // Fake a couple of requests
-  for (int i = 0; i < 12; i++) {
+  for (int i = 0; i < 12; i++)
+  {
     // Create a test request
-    const char* body = "";
+    char const * body = "";
     if (i % 2 == 0)
       body = "human";
     else if (i % 3 == 0)
@@ -193,12 +211,15 @@ auto main() -> int {
     ex::sender auto snd = handle_classify_request(req);
 
     // Pack this into a simplified flow and execute it asynchronously
-    ex::sender auto action = std::move(snd) | ex::then([](http_response resp) {
-                               std::ostringstream oss;
-                               oss << "Sending response: " << resp.status_code_ << " / "
-                                   << resp.body_ << "\n";
-                               std::cout << oss.str();
-                             });
+    ex::sender auto action = std::move(snd)
+                           | ex::then(
+                               [](http_response resp)
+                               {
+                                 std::ostringstream oss;
+                                 oss << "Sending response: " << resp.status_code_ << " / "
+                                     << resp.body_ << "\n";
+                                 std::cout << oss.str();
+                               });
     scope.spawn(ex::starts_on(sched, std::move(action)));
   }
 
diff --git a/examples/then.cpp b/examples/then.cpp
index 5f2d3f661..4f3af5dcb 100644
--- a/examples/then.cpp
+++ b/examples/then.cpp
@@ -22,11 +22,14 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Example code:
-auto main() -> int {
-  auto x = then(stdexec::just(42), [](int i) {
-    std::printf("Got: %d\n", i);
-    return i;
-  });
+auto main() -> int
+{
+  auto x = then(stdexec::just(42),
+                [](int i)
+                {
+                  std::printf("Got: %d\n", i);
+                  return i;
+                });
 
   // prints:
   //   Got: 42
diff --git a/include/._clangd_helper_file.cpp b/include/._clangd_helper_file.cpp
index 6f579e4c3..c3c19b976 100644
--- a/include/._clangd_helper_file.cpp
+++ b/include/._clangd_helper_file.cpp
@@ -28,5 +28,4 @@
 // than those in the parent (for example, if the subdirectory has a CMakeList.txt that defines additional executables).
 // This ensures clangd provides useful intellisense for headers in any subdirectory with a CMakeList.txt.
 
-auto main() -> int {
-}
+auto main() -> int {}
diff --git a/include/exec/detail/numa.hpp b/include/exec/detail/numa.hpp
index 94b6ad7a6..a46047ceb 100644
--- a/include/exec/detail/numa.hpp
+++ b/include/exec/detail/numa.hpp
@@ -37,7 +37,7 @@ namespace experimental::execution
 {
   namespace _numa
   {
-    using _small_t = void* [1];
+    using _small_t = void *[1];
 
     template <class T>
     using _is_small = STDEXEC::__mbool<sizeof(T) <= sizeof(_small_t)>;
@@ -47,27 +47,27 @@ namespace experimental::execution
       _storage() noexcept = default;
 
       template <STDEXEC::__not_decays_to<_storage> Ty>
-      explicit _storage(Ty&& value)
-        : ptr{new STDEXEC::__decay_t<Ty>{static_cast<Ty&&>(value)}}
+      explicit _storage(Ty &&value)
+        : ptr{new STDEXEC::__decay_t<Ty>{static_cast<Ty &&>(value)}}
       {}
 
       template <STDEXEC::__not_decays_to<_storage> Ty>
         requires(_is_small<STDEXEC::__decay_t<Ty>>::value)
-      explicit _storage(Ty&& value) noexcept(STDEXEC::__nothrow_decay_copyable<Ty>)
+      explicit _storage(Ty &&value) noexcept(STDEXEC::__nothrow_decay_copyable<Ty>)
         : buf{}
       {
-        ::new (static_cast<void*>(buf)) STDEXEC::__decay_t<Ty>{static_cast<Ty&&>(value)};
+        ::new (static_cast<void *>(buf)) STDEXEC::__decay_t<Ty>{static_cast<Ty &&>(value)};
       }
 
-      void* ptr{};
+      void *ptr{};
       char  buf[sizeof(_small_t)];
     };
 
     struct _vtable
     {
-      auto (*move)(_storage*, _storage*) noexcept -> void;
-      auto (*copy)(_storage*, _storage const *) -> void;
-      auto (*destroy)(_storage*) noexcept -> void;
+      auto (*move)(_storage *, _storage *) noexcept -> void;
+      auto (*copy)(_storage *, _storage const *) -> void;
+      auto (*destroy)(_storage *) noexcept -> void;
       auto (*num_nodes)(_storage const *) noexcept -> std::size_t;
       auto (*num_cpus)(_storage const *, int) noexcept -> std::size_t;
       auto (*bind_to_node)(_storage const *, int) noexcept -> int;
@@ -78,7 +78,7 @@ namespace experimental::execution
     struct _vtable_for
     {
       // move
-      static auto _move(_storage* self, _storage* other) noexcept -> void
+      static auto _move(_storage *self, _storage *other) noexcept -> void
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -86,13 +86,13 @@ namespace experimental::execution
         }
         else
         {
-          ::new (static_cast<void*>(self->buf))
-            T{static_cast<T&&>(*reinterpret_cast<T*>(other->buf))};
+          ::new (static_cast<void *>(self->buf))
+            T{static_cast<T &&>(*reinterpret_cast<T *>(other->buf))};
         }
       }
 
       // copy
-      static auto _copy(_storage* self, _storage const * other) noexcept -> void
+      static auto _copy(_storage *self, _storage const *other) noexcept -> void
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -100,25 +100,25 @@ namespace experimental::execution
         }
         else
         {
-          ::new (static_cast<void*>(self->buf)) T{*reinterpret_cast<T const *>(other->buf)};
+          ::new (static_cast<void *>(self->buf)) T{*reinterpret_cast<T const *>(other->buf)};
         }
       }
 
       // destroy
-      static auto _destroy(_storage* self) noexcept -> void
+      static auto _destroy(_storage *self) noexcept -> void
       {
         if constexpr (!_is_small<T>::value)
         {
-          delete static_cast<T*>(self->ptr);
+          delete static_cast<T *>(self->ptr);
         }
         else
         {
-          std::destroy_at(reinterpret_cast<T*>(self->buf));
+          std::destroy_at(reinterpret_cast<T *>(self->buf));
         }
       }
 
       // num_nodes
-      static auto _num_nodes(_storage const * self) noexcept -> std::size_t
+      static auto _num_nodes(_storage const *self) noexcept -> std::size_t
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -131,7 +131,7 @@ namespace experimental::execution
       }
 
       // num_cpus
-      static auto _num_cpus(_storage const * self, int node) noexcept -> std::size_t
+      static auto _num_cpus(_storage const *self, int node) noexcept -> std::size_t
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -144,7 +144,7 @@ namespace experimental::execution
       }
 
       // bind_to_node
-      static auto _bind_to_node(_storage const * self, int node) noexcept -> int
+      static auto _bind_to_node(_storage const *self, int node) noexcept -> int
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -157,7 +157,7 @@ namespace experimental::execution
       }
 
       // thread_index_to_node
-      static auto _thread_index_to_node(_storage const * self, std::size_t index) noexcept -> int
+      static auto _thread_index_to_node(_storage const *self, std::size_t index) noexcept -> int
       {
         if constexpr (!_is_small<T>::value)
         {
@@ -184,24 +184,24 @@ namespace experimental::execution
   struct numa_policy
   {
    private:
-    _numa::_vtable const * vtable_;
-    _numa::_storage        storage_;
+    _numa::_vtable const *vtable_;
+    _numa::_storage       storage_;
 
    public:
     template <STDEXEC::__not_decays_to<numa_policy> NumaPolicy>
-    numa_policy(NumaPolicy&& policy)
+    numa_policy(NumaPolicy &&policy)
       : vtable_(&_numa::_vtable_for_v<STDEXEC::__decay_t<NumaPolicy>>)
-      , storage_(static_cast<NumaPolicy&&>(policy))
+      , storage_(static_cast<NumaPolicy &&>(policy))
     {}
 
-    numa_policy(numa_policy&& other) noexcept
+    numa_policy(numa_policy &&other) noexcept
       : vtable_(other.vtable_)
       , storage_{}
     {
       vtable_->move(&storage_, &other.storage_);
     }
 
-    numa_policy(numa_policy const & other)
+    numa_policy(numa_policy const &other)
       : vtable_(other.vtable_)
       , storage_{}
     {
@@ -273,7 +273,7 @@ namespace experimental::execution
 {
   inline std::size_t _get_numa_num_cpus(int node)
   {
-    struct ::bitmask* cpus = ::numa_allocate_cpumask();
+    struct ::bitmask *cpus = ::numa_allocate_cpumask();
     if (!cpus)
     {
       return 0;
@@ -290,7 +290,7 @@ namespace experimental::execution
 
   struct _node_to_thread_index
   {
-    static std::vector<int> const & get() noexcept
+    static std::vector<int> const &get() noexcept
     {
       // This leaks one memory block at shutdown, but it's fine. Clang's and gcc's leak
       // sanitizer do not report it.
@@ -323,7 +323,7 @@ namespace experimental::execution
 
     int bind_to_node(int node) const noexcept
     {
-      struct ::bitmask* nodes = ::numa_allocate_nodemask();
+      struct ::bitmask *nodes = ::numa_allocate_nodemask();
       if (!nodes)
       {
         return -1;
@@ -336,8 +336,8 @@ namespace experimental::execution
 
     int thread_index_to_node(std::size_t idx) const noexcept
     {
-      auto const & node_to_thread_index = _node_to_thread_index::get();
-      int          index                = static_cast<int>(idx) % node_to_thread_index.back();
+      auto const &node_to_thread_index = _node_to_thread_index::get();
+      int         index                = static_cast<int>(idx) % node_to_thread_index.back();
       auto it = std::upper_bound(node_to_thread_index.begin(), node_to_thread_index.end(), index);
       STDEXEC_ASSERT(it != node_to_thread_index.end());
       return static_cast<int>(std::distance(node_to_thread_index.begin(), it));
@@ -356,7 +356,7 @@ namespace experimental::execution
   template <class T>
   struct numa_allocator
   {
-    using pointer       = T*;
+    using pointer       = T *;
     using const_pointer = T const *;
     using value_type    = T;
 
@@ -365,28 +365,28 @@ namespace experimental::execution
     {}
 
     template <class U>
-    explicit numa_allocator(numa_allocator<U> const & other) noexcept
+    explicit numa_allocator(numa_allocator<U> const &other) noexcept
       : node_(other.node_)
     {}
 
     int node_;
 
-    void* do_allocate(std::size_t n)
+    void *do_allocate(std::size_t n)
     {
       return ::numa_alloc_onnode(n, node_);
     }
 
-    void do_deallocate(void* p, std::size_t n)
+    void do_deallocate(void *p, std::size_t n)
     {
       ::numa_free(p, n);
     }
 
-    T* allocate(std::size_t n)
+    T *allocate(std::size_t n)
     {
-      return static_cast<T*>(do_allocate(n * sizeof(T)));
+      return static_cast<T *>(do_allocate(n * sizeof(T)));
     }
 
-    void deallocate(T* p, std::size_t n)
+    void deallocate(T *p, std::size_t n)
     {
       do_deallocate(p, n * sizeof(T));
     }
@@ -410,7 +410,7 @@ namespace experimental::execution
       ::copy_bitmask_to_nodemask(::numa_no_nodes_ptr, &mask_);
     }
 
-    static nodemask const & any() noexcept
+    static nodemask const &any() noexcept
     {
       static STDEXEC::__indestructible<nodemask> const mask{make_any()};
       return mask.get();
@@ -419,7 +419,7 @@ namespace experimental::execution
     bool operator[](std::size_t nodemask) const noexcept
     {
       ::bitmask mask;
-      mask.maskp = const_cast<unsigned long*>(mask_.n);
+      mask.maskp = const_cast<unsigned long *>(mask_.n);
       mask.size  = sizeof(nodemask_t);
       return ::numa_bitmask_isbitset(&mask, static_cast<unsigned int>(nodemask));
     }
@@ -427,7 +427,7 @@ namespace experimental::execution
     void set(std::size_t nodemask) noexcept
     {
       ::bitmask mask;
-      mask.maskp = const_cast<unsigned long*>(mask_.n);
+      mask.maskp = const_cast<unsigned long *>(mask_.n);
       mask.size  = sizeof(nodemask_t);
       ::numa_bitmask_setbit(&mask, static_cast<unsigned int>(nodemask));
     }
@@ -435,18 +435,18 @@ namespace experimental::execution
     bool get(std::size_t nodemask) const noexcept
     {
       ::bitmask mask;
-      mask.maskp = const_cast<unsigned long*>(mask_.n);
+      mask.maskp = const_cast<unsigned long *>(mask_.n);
       mask.size  = sizeof(nodemask_t);
       return ::numa_bitmask_isbitset(&mask, static_cast<unsigned int>(nodemask));
     }
 
-    friend bool operator==(nodemask const & lhs, nodemask const & rhs) noexcept
+    friend bool operator==(nodemask const &lhs, nodemask const &rhs) noexcept
     {
       ::bitmask lhs_mask;
       ::bitmask rhs_mask;
-      lhs_mask.maskp = const_cast<unsigned long*>(lhs.mask_.n);
+      lhs_mask.maskp = const_cast<unsigned long *>(lhs.mask_.n);
       lhs_mask.size  = sizeof(nodemask_t);
-      rhs_mask.maskp = const_cast<unsigned long*>(rhs.mask_.n);
+      rhs_mask.maskp = const_cast<unsigned long *>(rhs.mask_.n);
       rhs_mask.size  = sizeof(nodemask_t);
       return ::numa_bitmask_equal(&lhs_mask, &rhs_mask);
     }
@@ -471,7 +471,7 @@ namespace experimental::execution
   template <class T>
   struct numa_allocator
   {
-    using pointer       = T*;
+    using pointer       = T *;
     using const_pointer = T const *;
     using value_type    = T;
 
@@ -481,13 +481,13 @@ namespace experimental::execution
     explicit numa_allocator(numa_allocator<U> const &) noexcept
     {}
 
-    auto allocate(std::size_t n) -> T*
+    auto allocate(std::size_t n) -> T *
     {
       std::allocator<T> alloc{};
       return alloc.allocate(n);
     }
 
-    void deallocate(T* p, std::size_t n)
+    void deallocate(T *p, std::size_t n)
     {
       std::allocator<T> alloc{};
       alloc.deallocate(p, n);
@@ -525,7 +525,7 @@ namespace experimental::execution
       mask_ |= nodemask == 0;
     }
 
-    friend auto operator==(nodemask const & lhs, nodemask const & rhs) noexcept -> bool
+    friend auto operator==(nodemask const &lhs, nodemask const &rhs) noexcept -> bool
     {
       return lhs.mask_ == rhs.mask_;
     }
diff --git a/include/exec/detail/system_context_replaceability_api.hpp b/include/exec/detail/system_context_replaceability_api.hpp
index 5dbe1da0c..462f55bd9 100644
--- a/include/exec/detail/system_context_replaceability_api.hpp
+++ b/include/exec/detail/system_context_replaceability_api.hpp
@@ -60,9 +60,9 @@ namespace experimental::execution::system_context_replaceability
 
   /// Interface for completing a sender operation. Backend will call frontend though this interface
   /// for completing the `schedule` and `schedule_bulk` operations.
-  using receiver [[deprecated("Use STDEXEC::system_context_replaceability::receiver_proxy "
-                              "instead.")]] =
-    STDEXEC::system_context_replaceability::receiver_proxy;
+  using receiver
+    [[deprecated("Use STDEXEC::system_context_replaceability::receiver_proxy "
+                 "instead.")]] = STDEXEC::system_context_replaceability::receiver_proxy;
 
   /// Receiver for bulk scheduling operations.
   using bulk_item_receiver
diff --git a/include/exec/sequence.hpp b/include/exec/sequence.hpp
index 9f7097777..a7f2d3ef8 100644
--- a/include/exec/sequence.hpp
+++ b/include/exec/sequence.hpp
@@ -157,9 +157,9 @@ namespace experimental::execution
       STDEXEC_ATTRIBUTE(host, device)
       constexpr explicit _opstate(Rcvr&& rcvr, CvSndrs&& sndrs)
         : _opstate_base<Rcvr>{static_cast<Rcvr&&>(rcvr)}
-        , _sndrs{STDEXEC::__apply(__convert_tuple_fn<_senders_tuple_t>{},
-                                  static_cast<CvSndrs&&>(sndrs))}
-        // move all but the first sender into the opstate.
+        , _sndrs{
+            STDEXEC::__apply(__convert_tuple_fn<_senders_tuple_t>{}, static_cast<CvSndrs&&>(sndrs))}
+      // move all but the first sender into the opstate.
       {
         // Below, it looks like we are using `sndrs` after it has been moved from. This is not the
         // case. `sndrs` is moved into a tuple type that has `__ignore` for the first element. The
diff --git a/include/exec/thread_pool_base.hpp b/include/exec/thread_pool_base.hpp
index b4ebfe8a2..c19270fb1 100644
--- a/include/exec/thread_pool_base.hpp
+++ b/include/exec/thread_pool_base.hpp
@@ -341,9 +341,9 @@ namespace experimental::execution
                                        STDEXEC::__mbind_front_q<bulk_non_throwing, Fun, Shape>,
                                        STDEXEC::__q<STDEXEC::__mand>>::value;
 
-        using bulk_rcvr      = bulk_receiver<CvSender, Receiver, Shape, Fun, may_throw>;
-        using shared_state   = bulk_shared_state<CvSender, Receiver, Shape, Fun, may_throw>;
-        using inner_opstate  = STDEXEC::connect_result_t<CvSender, bulk_rcvr>;
+        using bulk_rcvr     = bulk_receiver<CvSender, Receiver, Shape, Fun, may_throw>;
+        using shared_state  = bulk_shared_state<CvSender, Receiver, Shape, Fun, may_throw>;
+        using inner_opstate = STDEXEC::connect_result_t<CvSender, bulk_rcvr>;
 
         void start() & noexcept
         {
diff --git a/include/exec/timed_scheduler.hpp b/include/exec/timed_scheduler.hpp
index 6e4b9dd31..7384c4412 100644
--- a/include/exec/timed_scheduler.hpp
+++ b/include/exec/timed_scheduler.hpp
@@ -150,13 +150,13 @@ namespace experimental::execution
       // __schedule_after_base_t class.
       template <class _Scheduler>
         requires __callable<__schedule_after_base_t, _Scheduler, duration_of_t<_Scheduler> const &>
-      auto operator()(_Scheduler&& __sched, duration_of_t<_Scheduler> const & __time_point) const
+      auto operator()(_Scheduler &&__sched, duration_of_t<_Scheduler> const &__time_point) const
         noexcept(__nothrow_callable<__schedule_after_base_t,
                                     _Scheduler,
                                     duration_of_t<_Scheduler> const &>)
           -> __call_result_t<__schedule_after_base_t, _Scheduler, duration_of_t<_Scheduler> const &>
       {
-        return __schedule_after_base_t{}(static_cast<_Scheduler&&>(__sched), __time_point);
+        return __schedule_after_base_t{}(static_cast<_Scheduler &&>(__sched), __time_point);
       }
 #endif
 
@@ -230,12 +230,12 @@ namespace experimental::execution
       // __schedule_at_base_t class.
       template <class _Scheduler>
         requires __callable<__schedule_at_base_t, _Scheduler, time_point_of_t<_Scheduler> const &>
-      auto operator()(_Scheduler&& __sched, time_point_of_t<_Scheduler> const & __time_point) const
+      auto operator()(_Scheduler &&__sched, time_point_of_t<_Scheduler> const &__time_point) const
         noexcept(
           __nothrow_callable<__schedule_at_base_t, _Scheduler, time_point_of_t<_Scheduler> const &>)
           -> __call_result_t<__schedule_at_base_t, _Scheduler, time_point_of_t<_Scheduler> const &>
       {
-        return __schedule_at_base_t{}(static_cast<_Scheduler&&>(__sched), __time_point);
+        return __schedule_at_base_t{}(static_cast<_Scheduler &&>(__sched), __time_point);
       }
 #endif
 
diff --git a/include/stdexec/__detail/__deprecations.hpp b/include/stdexec/__detail/__deprecations.hpp
index 8775ca984..afbe0a8c4 100644
--- a/include/stdexec/__detail/__deprecations.hpp
+++ b/include/stdexec/__detail/__deprecations.hpp
@@ -40,9 +40,9 @@ namespace STDEXEC
                                           "inplace_stop_source")]] = inplace_stop_source;
 
   template <class _Fun>
-  using in_place_stop_callback [[deprecated("in_place_stop_callback has been renamed "
-                                            "inplace_stop_callback")]] =
-    inplace_stop_callback<_Fun>;
+  using in_place_stop_callback
+    [[deprecated("in_place_stop_callback has been renamed "
+                 "inplace_stop_callback")]] = inplace_stop_callback<_Fun>;
 
   using start_on_t [[deprecated("start_on_t has been renamed starts_on_t")]] = starts_on_t;
   [[deprecated("start_on has been renamed starts_on")]]
diff --git a/include/stdexec/__detail/__domain.hpp b/include/stdexec/__detail/__domain.hpp
index f97e64427..162d59db6 100644
--- a/include/stdexec/__detail/__domain.hpp
+++ b/include/stdexec/__detail/__domain.hpp
@@ -34,15 +34,15 @@ namespace STDEXEC
   {
     template <class _DomainOrTag, class _OpTag, class _Sender, class... _Env>
     concept __has_transform_sender = requires(_DomainOrTag __tag,
-                                              _Sender&&    __sender,
-                                              _Env const &... __env) {
+                                              _Sender    &&__sender,
+                                              _Env const &...__env) {
       __tag.transform_sender(_OpTag(), static_cast<_Sender &&>(__sender), __env...);
     };
 
     template <class _DomainOrTag, class _OpTag, class _Sender, class... _Env>
     concept __has_nothrow_transform_sender = requires(_DomainOrTag __tag,
-                                                      _Sender&&    __sender,
-                                                      _Env const &... __env) {
+                                                      _Sender    &&__sender,
+                                                      _Env const &...__env) {
       { __tag.transform_sender(_OpTag(), static_cast<_Sender &&>(__sender), __env...) } noexcept;
     };
 
@@ -53,7 +53,7 @@ namespace STDEXEC
                                                __declval<_Env const &>()...));
 
     template <class _DomainOrTag, class... _Args>
-    concept __has_apply_sender = requires(_DomainOrTag __tag, _Args&&... __args) {
+    concept __has_apply_sender = requires(_DomainOrTag __tag, _Args &&...__args) {
       __tag.apply_sender(static_cast<_Args &&>(__args)...);
     };
 
@@ -67,28 +67,28 @@ namespace STDEXEC
     template <class _OpTag, class _Sender, class _Env>
       requires __detail::__has_transform_sender<tag_of_t<_Sender>, _OpTag, _Sender, _Env>
     STDEXEC_ATTRIBUTE(always_inline)
-    constexpr auto transform_sender(_OpTag, _Sender&& __sndr, _Env const & __env) const
+    constexpr auto transform_sender(_OpTag, _Sender &&__sndr, _Env const &__env) const
       noexcept(__detail::__has_nothrow_transform_sender<tag_of_t<_Sender>, _OpTag, _Sender, _Env>)
         -> __detail::__transform_sender_result_t<tag_of_t<_Sender>, _OpTag, _Sender, _Env>
     {
-      return tag_of_t<_Sender>().transform_sender(_OpTag(), static_cast<_Sender&&>(__sndr), __env);
+      return tag_of_t<_Sender>().transform_sender(_OpTag(), static_cast<_Sender &&>(__sndr), __env);
     }
 
     template <class _OpTag, class _Sender, class _Env>
     STDEXEC_ATTRIBUTE(always_inline)
-    constexpr auto transform_sender(_OpTag, _Sender&& __sndr, _Env const &) const
+    constexpr auto transform_sender(_OpTag, _Sender &&__sndr, _Env const &) const
       noexcept(__nothrow_move_constructible<_Sender>) -> _Sender
     {
-      return static_cast<_Sender>(static_cast<_Sender&&>(__sndr));
+      return static_cast<_Sender>(static_cast<_Sender &&>(__sndr));
     }
 
     template <class _Tag, class... _Args>
       requires __detail::__has_apply_sender<_Tag, _Args...>
     STDEXEC_ATTRIBUTE(always_inline)
-    constexpr auto apply_sender(_Tag, _Args&&... __args) const
+    constexpr auto apply_sender(_Tag, _Args &&...__args) const
       -> __detail::__apply_sender_result_t<_Tag, _Args...>
     {
-      return _Tag().apply_sender(static_cast<_Args&&>(__args)...);
+      return _Tag().apply_sender(static_cast<_Args &&>(__args)...);
     }
   };
 
@@ -129,13 +129,13 @@ namespace STDEXEC
     template <class _OpTag, class _Sndr, class _Env>
       requires __detail::__has_transform_sender<tag_of_t<_Sndr>, _OpTag, _Sndr, _Env>
     [[nodiscard]]
-    static constexpr auto transform_sender(_OpTag, _Sndr&& __sndr, _Env const & __env)
+    static constexpr auto transform_sender(_OpTag, _Sndr &&__sndr, _Env const &__env)
       noexcept(__detail::__has_nothrow_transform_sender<tag_of_t<_Sndr>, _OpTag, _Sndr, _Env>)
         -> __detail::__transform_sender_result_t<tag_of_t<_Sndr>, _OpTag, _Sndr, _Env>
     {
       static_assert((__default_domain_like<_Domains, _OpTag, _Sndr, _Env> && ...),
                     "ERROR: indeterminate domains: cannot pick an algorithm customization");
-      return tag_of_t<_Sndr>{}.transform_sender(_OpTag{}, static_cast<_Sndr&&>(__sndr), __env);
+      return tag_of_t<_Sndr>{}.transform_sender(_OpTag{}, static_cast<_Sndr &&>(__sndr), __env);
     }
   };
 
@@ -194,10 +194,9 @@ namespace STDEXEC
     using __scheduler_domain_t =
       __call_result_t<get_completion_domain_t<set_value_t>, _Sch, _Env...>;
 
-    constexpr auto
-    __find_pos(bool const * const __begin, bool const * const __end) noexcept -> size_t
+    constexpr auto __find_pos(bool const *const __begin, bool const *const __end) noexcept -> size_t
     {
-      for (bool const * __where = __begin; __where != __end; ++__where)
+      for (bool const *__where = __begin; __where != __end; ++__where)
       {
         if (*__where)
         {
@@ -212,17 +211,17 @@ namespace STDEXEC
   template <class _Env, class... _Queries>
   struct __hide_query
   {
-    constexpr explicit __hide_query(_Env&& __env, _Queries...) noexcept
-      : __env_{static_cast<_Env&&>(__env)}
+    constexpr explicit __hide_query(_Env &&__env, _Queries...) noexcept
+      : __env_{static_cast<_Env &&>(__env)}
     {}
 
     template <__none_of<_Queries...> _Query, class... _As>
       requires __queryable_with<_Env, _Query, _As...>
     constexpr auto
-    operator()(_Query, _As&&... __as) const noexcept(__nothrow_queryable_with<_Env, _Query, _As...>)
+    operator()(_Query, _As &&...__as) const noexcept(__nothrow_queryable_with<_Env, _Query, _As...>)
       -> __query_result_t<_Env, _Query, _As...>
     {
-      return __query<_Query>()(__env_, static_cast<_As&&>(__as)...);
+      return __query<_Query>()(__env_, static_cast<_As &&>(__as)...);
     }
 
    private:
@@ -231,20 +230,20 @@ namespace STDEXEC
 
   template <class _Env, class... _Queries>
   STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
-  __hide_query(_Env&&, _Queries...) -> __hide_query<_Env, _Queries...>;
+  __hide_query(_Env &&, _Queries...) -> __hide_query<_Env, _Queries...>;
 
   //! @brief A wrapper around an environment that hides the get_scheduler and get_domain
   //! queries.
   template <class _Env>
   struct __hide_scheduler : __hide_query<_Env, get_scheduler_t, get_domain_t>
   {
-    constexpr explicit __hide_scheduler(_Env&& __env) noexcept
-      : __hide_query<_Env, get_scheduler_t, get_domain_t>{static_cast<_Env&&>(__env), {}, {}}
+    constexpr explicit __hide_scheduler(_Env &&__env) noexcept
+      : __hide_query<_Env, get_scheduler_t, get_domain_t>{static_cast<_Env &&>(__env), {}, {}}
     {}
   };
 
   template <class _Env>
-  STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __hide_scheduler(_Env&&) -> __hide_scheduler<_Env>;
+  STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE __hide_scheduler(_Env &&) -> __hide_scheduler<_Env>;
 
   //////////////////////////////////////////////////////////////////////////////////////////
   //! @brief A query type for asking a sender's attributes for the domain on which that
diff --git a/include/stdexec/__detail/__env.hpp b/include/stdexec/__detail/__env.hpp
index c43130470..711bec425 100644
--- a/include/stdexec/__detail/__env.hpp
+++ b/include/stdexec/__detail/__env.hpp
@@ -42,7 +42,7 @@ namespace STDEXEC
     struct cprop
     {
       STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      static constexpr auto query(_Query, auto&&...) noexcept
+      static constexpr auto query(_Query, auto &&...) noexcept
       {
         return _Value;
       }
@@ -56,11 +56,11 @@ namespace STDEXEC
       template <__forwarding_query _Query, class... _Args>
         requires __queryable_with<_Env, _Query, _Args...>
       STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto query(_Query, _Args&&... __args) const
+      constexpr auto query(_Query, _Args &&...__args) const
         noexcept(__nothrow_queryable_with<_Env, _Query, _Args...>)
           -> __query_result_t<_Env, _Query, _Args...>
       {
-        return __query<_Query>()(__env_, static_cast<_Args&&>(__args)...);
+        return __query<_Query>()(__env_, static_cast<_Args &&>(__args)...);
       }
 
       STDEXEC_ATTRIBUTE(no_unique_address)
@@ -74,15 +74,15 @@ namespace STDEXEC
     {
       template <class _Env>
       STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()(_Env&& __env) const -> decltype(auto)
+      constexpr auto operator()(_Env &&__env) const -> decltype(auto)
       {
         if constexpr (__decays_to<_Env, env<>> || __is_fwd_env<_Env>)
         {
-          return static_cast<_Env>(static_cast<_Env&&>(__env));
+          return static_cast<_Env>(static_cast<_Env &&>(__env));
         }
         else
         {
-          return __fwd<_Env>{static_cast<_Env&&>(__env)};
+          return __fwd<_Env>{static_cast<_Env &&>(__env)};
         }
       }
     };
@@ -94,20 +94,20 @@ namespace STDEXEC
     {
       template <class _Env1, class _Env2>
       STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-      constexpr auto operator()(_Env1&& __env1, _Env2&& __env2) const noexcept -> decltype(auto)
+      constexpr auto operator()(_Env1 &&__env1, _Env2 &&__env2) const noexcept -> decltype(auto)
       {
         if constexpr (__decays_to<_Env1, env<>>)
         {
-          return __fwd_fn()(static_cast<_Env2&&>(__env2));
+          return __fwd_fn()(static_cast<_Env2 &&>(__env2));
         }
         else if constexpr (__decays_to<_Env2, env<>>)
         {
-          return static_cast<_Env1>(static_cast<_Env1&&>(__env1));
+          return static_cast<_Env1>(static_cast<_Env1 &&>(__env1));
         }
         else
         {
-          return env<_Env1, __fwd_env_t<_Env2>>{{static_cast<_Env1&&>(__env1)},
-                                                __fwd_fn()(static_cast<_Env2&&>(__env2))};
+          return env<_Env1, __fwd_env_t<_Env2>>{{static_cast<_Env1 &&>(__env1)},
+                                                __fwd_fn()(static_cast<_Env2 &&>(__env2))};
         }
       }
     };
@@ -142,7 +142,7 @@ namespace STDEXEC
       constexpr auto operator()(_Env __env) const noexcept
         -> __join_env_t<__root_env, std::unwrap_reference_t<_Env>>
       {
-        return __join(__root_env{}, static_cast<std::unwrap_reference_t<_Env>&&>(__env));
+        return __join(__root_env{}, static_cast<std::unwrap_reference_t<_Env> &&>(__env));
       }
     };
 
@@ -160,7 +160,7 @@ namespace STDEXEC
   using __as_root_env_t = __result_of<__as_root_env, _Env>;
 
   template <class _Env>
-  concept __is_root_env = requires(_Env&& __env) {
+  concept __is_root_env = requires(_Env &&__env) {
     { __root_t{}(__env) } -> __std::same_as<bool>;
   };
 
@@ -170,7 +170,7 @@ namespace STDEXEC
   struct prop
   {
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto query(_Query, auto&&...) const noexcept -> _Value const &
+    constexpr auto query(_Query, auto &&...) const noexcept -> _Value const &
     {
       return __value;
     }
@@ -217,22 +217,22 @@ namespace STDEXEC
     template <class _Query, class... _Args>
       requires __queryable_with<_Env1, _Query, _Args...>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto query(_Query, _Args&&... __args) const
+    constexpr auto query(_Query, _Args &&...__args) const
       noexcept(__nothrow_queryable_with<_Env1, _Query, _Args...>)
         -> __query_result_t<_Env1, _Query, _Args...>
     {
-      return __query<_Query>()(__env1_, static_cast<_Args&&>(__args)...);
+      return __query<_Query>()(__env1_, static_cast<_Args &&>(__args)...);
     }
 
     template <class _Query, class... _Args>
       requires __queryable_with<_Env1, _Query, _Args...>
             || __queryable_with<_Env2, _Query, _Args...>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto query(_Query, _Args&&... __args) const
+    constexpr auto query(_Query, _Args &&...__args) const
       noexcept(__nothrow_queryable_with<_Env2, _Query, _Args...>)
         -> __query_result_t<_Env2, _Query, _Args...>
     {
-      return __query<_Query>()(__env2_, static_cast<_Args&&>(__args)...);
+      return __query<_Query>()(__env2_, static_cast<_Args &&>(__args)...);
     }
 
     STDEXEC_ATTRIBUTE(no_unique_address) _Env1 __env1_;
@@ -262,7 +262,7 @@ namespace STDEXEC
     template <class _EnvProvider>
       requires __detail::__has_get_env_member<_EnvProvider const &>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto operator()(_EnvProvider const & __env_provider) const noexcept
+    constexpr auto operator()(_EnvProvider const &__env_provider) const noexcept
       -> __detail::__get_env_member_result_t<_EnvProvider const &>
     {
       static_assert(noexcept(__env_provider.get_env()), "get_env() members must be noexcept");
@@ -274,7 +274,7 @@ namespace STDEXEC
             || __tag_invocable<get_env_t, _EnvProvider const &>
     [[deprecated("the use of tag_invoke for get_env is deprecated")]]
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)  //
-      constexpr auto operator()(_EnvProvider const & __env_provider) const noexcept
+      constexpr auto operator()(_EnvProvider const &__env_provider) const noexcept
       -> __tag_invoke_result_t<get_env_t, _EnvProvider const &>
     {
       static_assert(__nothrow_tag_invocable<get_env_t, _EnvProvider const &>,
diff --git a/include/stdexec/__detail/__get_completion_signatures.hpp b/include/stdexec/__detail/__get_completion_signatures.hpp
index 5425a6516..4f4d9b8a5 100644
--- a/include/stdexec/__detail/__get_completion_signatures.hpp
+++ b/include/stdexec/__detail/__get_completion_signatures.hpp
@@ -69,14 +69,14 @@ namespace STDEXEC
     concept __non_sender = !enable_sender<__decay_t<_Ty>>;
 
     template <__valid_completion_signatures _Completions>
-    consteval auto __checked_complsigs(_Completions, void*)
+    consteval auto __checked_complsigs(_Completions, void *)
     {
       return _Completions();
     }
 
     template <class _Completions, class _Sender, class... _Env>
       requires(!__valid_completion_signatures<_Completions>)
-    consteval auto __checked_complsigs(_Completions, __mlist<_Sender, _Env...>*)
+    consteval auto __checked_complsigs(_Completions, __mlist<_Sender, _Env...> *)
     {
       if constexpr (__merror<_Completions>)
       {
@@ -116,14 +116,14 @@ namespace STDEXEC
     using __legacy_member_alias_t = STDEXEC_REMOVE_REFERENCE(_Sender)::completion_signatures;
 
     template <class _Sender, class... _Env>
-    concept __with_legacy_member = requires(__declfn_t<_Sender&&> __sndr,
-                                            __declfn_t<_Env&&>... __env) {
+    concept __with_legacy_member = requires(__declfn_t<_Sender &&> __sndr,
+                                            __declfn_t<_Env &&>... __env) {
       __sndr().get_completion_signatures(__env()...);
     };
 
     template <class _Sender, class... _Env>
-    concept __with_legacy_static_member = requires(__declfn_t<_Sender&&> __sndr,
-                                                   __declfn_t<_Env&&>... __env) {
+    concept __with_legacy_static_member = requires(__declfn_t<_Sender &&> __sndr,
+                                                   __declfn_t<_Env &&>... __env) {
       STDEXEC_REMOVE_REFERENCE(_Sender)
       ::static_get_completion_signatures(__sndr(), __env()...);
     };
@@ -166,8 +166,8 @@ namespace STDEXEC
   }  // namespace __cmplsigs
 
   template <class _Sender, class _Env>
-  concept __has_get_completion_signatures = requires(__declfn_t<_Sender&&> __sndr,
-                                                     __declfn_t<_Env&&>    __env) {
+  concept __has_get_completion_signatures = requires(__declfn_t<_Sender &&> __sndr,
+                                                     __declfn_t<_Env &&>    __env) {
     { transform_sender(__sndr(), __env()) } -> __cmplsigs::__with<_Env>;
   };
 
@@ -260,13 +260,13 @@ namespace STDEXEC
     struct get_completion_signatures_t
     {
       template <class _Sender>
-      constexpr auto operator()(_Sender&&) const noexcept
+      constexpr auto operator()(_Sender &&) const noexcept
       {
         return __cmplsigs::__get_completion_signatures_helper<_Sender>();
       }
 
       template <class _Sender, class _Env>
-      constexpr auto operator()(_Sender&&, _Env const &) const noexcept
+      constexpr auto operator()(_Sender &&, _Env const &) const noexcept
       {
         using __new_sndr_t = transform_sender_result_t<_Sender, _Env>;
         static_assert(!__merror<__new_sndr_t>);
@@ -295,7 +295,7 @@ namespace STDEXEC
   // Legacy interface:
   template <class _Sender, class... _Env>
     requires(sizeof...(_Env) <= 1)
-  constexpr auto get_completion_signatures(_Sender&&, _Env const &...) noexcept
+  constexpr auto get_completion_signatures(_Sender &&, _Env const &...) noexcept
   {
     return STDEXEC::get_completion_signatures<_Sender, _Env...>();
   }
@@ -332,7 +332,7 @@ namespace STDEXEC
     (void) STDEXEC::get_completion_signatures<_Sender>();
     return false;  // didn't throw, not a dependent sender
   }
-  catch (dependent_sender_error&)
+  catch (dependent_sender_error &)
   {
     return true;
   }
diff --git a/include/stdexec/__detail/__inline_scheduler.hpp b/include/stdexec/__detail/__inline_scheduler.hpp
index fc7dcc5c8..ca70dbfed 100644
--- a/include/stdexec/__detail/__inline_scheduler.hpp
+++ b/include/stdexec/__detail/__inline_scheduler.hpp
@@ -45,7 +45,7 @@ namespace STDEXEC
       STDEXEC_ATTRIBUTE(host, device)
       constexpr void start() noexcept
       {
-        STDEXEC::set_value(static_cast<_Receiver&&>(__rcvr_));
+        STDEXEC::set_value(static_cast<_Receiver &&>(__rcvr_));
       }
 
       _Receiver __rcvr_;
@@ -60,7 +60,7 @@ namespace STDEXEC
       STDEXEC_ATTRIBUTE(nodiscard, host, device)
       static constexpr auto connect(_Receiver __rcvr) noexcept -> __opstate<_Receiver>
       {
-        return {static_cast<_Receiver&&>(__rcvr)};
+        return {static_cast<_Receiver &&>(__rcvr)};
       }
 
       STDEXEC_ATTRIBUTE(nodiscard, host, device)
diff --git a/include/stdexec/__detail/__memory.hpp b/include/stdexec/__detail/__memory.hpp
index 9e93956ae..5ae8fb795 100644
--- a/include/stdexec/__detail/__memory.hpp
+++ b/include/stdexec/__detail/__memory.hpp
@@ -43,7 +43,7 @@ namespace STDEXEC
 
   template <class _Ty, class _Alloc, class... _Args>
   [[nodiscard]]
-  constexpr auto __allocate_unique(_Alloc const & __alloc, _Args&&... __args)
+  constexpr auto __allocate_unique(_Alloc const &__alloc, _Args &&...__args)
     -> std::unique_ptr<_Ty, __detail::__alloc_deleter<_Alloc>>
   {
     using __value_t   = std::allocator_traits<_Alloc>::value_type;
@@ -58,7 +58,7 @@ namespace STDEXEC
                           1ul};
     std::allocator_traits<_Alloc>::construct(__alloc2,
                                              std::addressof(*__ptr),
-                                             static_cast<_Args&&>(__args)...);
+                                             static_cast<_Args &&>(__args)...);
     __guard.__dismiss();
     return std::unique_ptr<_Ty, __deleter_t>(__ptr, __deleter_t{__alloc2});
   }
@@ -68,7 +68,7 @@ namespace STDEXEC
   // already bound to the correct type, in which case it is returned as-is.
   template <class _Ty, class _Alloc>
   [[nodiscard]]
-  constexpr auto __rebind_allocator(_Alloc const & __alloc) noexcept
+  constexpr auto __rebind_allocator(_Alloc const &__alloc) noexcept
   {
     using __rebound_alloc_t = std::allocator_traits<_Alloc>::template rebind_alloc<_Ty>;
     static_assert(noexcept(__rebound_alloc_t(__alloc)));
@@ -78,7 +78,7 @@ namespace STDEXEC
   template <class _Ty, class _Alloc>
     requires __same_as<_Ty, typename _Alloc::value_type>
   [[nodiscard]]
-  constexpr auto __rebind_allocator(_Alloc const & __alloc) noexcept -> _Alloc const &
+  constexpr auto __rebind_allocator(_Alloc const &__alloc) noexcept -> _Alloc const &
   {
     return __alloc;  // NOLINT(bugprone-return-const-ref-from-parameter)
   }
diff --git a/include/stdexec/__detail/__queries.hpp b/include/stdexec/__detail/__queries.hpp
index 9e0f5205c..62df2b7b7 100644
--- a/include/stdexec/__detail/__queries.hpp
+++ b/include/stdexec/__detail/__queries.hpp
@@ -119,14 +119,14 @@ namespace STDEXEC
     template <__forwarding_query _Query, class... _Args>
       requires __queryable_with<env_of_t<_Sender>, _Query, _Args...>
     [[nodiscard]]
-    constexpr auto query(_Query, _Args&&... __args) const
+    constexpr auto query(_Query, _Args &&...__args) const
       noexcept(__nothrow_queryable_with<env_of_t<_Sender>, _Query, _Args...>)
         -> __query_result_t<env_of_t<_Sender>, _Query, _Args...>
     {
-      return __query<_Query>()(get_env(__sndr_), static_cast<_Args&&>(__args)...);
+      return __query<_Query>()(get_env(__sndr_), static_cast<_Args &&>(__args)...);
     }
 
-    _Sender const & __sndr_;
+    _Sender const &__sndr_;
   };
 
   template <class _Sender>
diff --git a/include/stdexec/__detail/__query.hpp b/include/stdexec/__detail/__query.hpp
index e71c6393c..1c694773a 100644
--- a/include/stdexec/__detail/__query.hpp
+++ b/include/stdexec/__detail/__query.hpp
@@ -33,17 +33,17 @@ namespace STDEXEC
 
   template <class _Env, class _Query, class... _Args>
   concept __member_queryable_with = __queryable<_Env>
-                                 && requires(_Env const &   __env,
-                                             _Query const & __query,
-                                             __declfn_t<_Args&&>... __args) {
+                                 && requires(_Env const   &__env,
+                                             _Query const &__query,
+                                             __declfn_t<_Args &&>... __args) {
                                       { __env.query(__query, __args()...) };
                                     };
 
   template <class _Env, class _Query, class... _Args>
   concept __nothrow_member_queryable_with = __member_queryable_with<_Env, _Query, _Args...>
-                                         && requires(_Env const &   __env,
-                                                     _Query const & __query,
-                                                     __declfn_t<_Args&&>... __args) {
+                                         && requires(_Env const   &__env,
+                                                     _Query const &__query,
+                                                     __declfn_t<_Args &&>... __args) {
                                               { __env.query(__query, __args()...) } noexcept;
                                             };
 
@@ -65,7 +65,7 @@ namespace STDEXEC
 
     template <class... _Args>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto operator()(__ignore, _Args&&...) const noexcept  //
+    constexpr auto operator()(__ignore, _Args &&...) const noexcept  //
       -> __mcall1<_Transform, __mtypeof<_Default>>
     {
       return _Default;
@@ -82,7 +82,7 @@ namespace STDEXEC
     template <class _Qy = _Query, class _Env, class... _Args>
       requires __member_queryable_with<_Env const &, _Qy, _Args...>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
-    constexpr auto operator()(_Env const & __env, _Args&&... __args) const
+    constexpr auto operator()(_Env const &__env, _Args &&...__args) const
       noexcept(__nothrow_member_queryable_with<_Env, _Qy, _Args...>)
         -> __mcall1<_Transform, __member_query_result_t<_Env, _Qy, _Args...>>
     {
@@ -90,7 +90,7 @@ namespace STDEXEC
       {
         _Query::template __validate<_Env, _Args...>();
       }
-      return __env.query(_Query(), static_cast<_Args&&>(__args)...);
+      return __env.query(_Query(), static_cast<_Args &&>(__args)...);
     }
 
     // Query with tag_invoke (legacy):
@@ -98,7 +98,7 @@ namespace STDEXEC
       requires __tag_invocable<_Qy, _Env const &, _Args...>
     [[deprecated("the use of tag_invoke for queries is deprecated")]]
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)  //
-      constexpr auto operator()(_Env const & __env, _Args&&... __args) const
+      constexpr auto operator()(_Env const &__env, _Args &&...__args) const
       noexcept(__nothrow_tag_invocable<_Qy, _Env const &, _Args...>)
         -> __mcall1<_Transform, __tag_invoke_result_t<_Qy, _Env const &, _Args...>>
     {
@@ -106,21 +106,21 @@ namespace STDEXEC
       {
         _Query::template __validate<_Env, _Args...>();
       }
-      return __tag_invoke(_Query(), __env, static_cast<_Args&&>(__args)...);
+      return __tag_invoke(_Query(), __env, static_cast<_Args &&>(__args)...);
     }
   };
 
   template <class _Env, class _Query, class... _Args>
-  concept __queryable_with = __callable<__query<_Query>, _Env&, _Args...>;
+  concept __queryable_with = __callable<__query<_Query>, _Env &, _Args...>;
 
   template <class _Env, class _Query, class... _Args>
-  concept __nothrow_queryable_with = __nothrow_callable<__query<_Query>, _Env&, _Args...>;
+  concept __nothrow_queryable_with = __nothrow_callable<__query<_Query>, _Env &, _Args...>;
 
   template <class _Env, class _Query, class... _Args>
-  using __query_result_t = __call_result_t<__query<_Query>, _Env&, _Args...>;
+  using __query_result_t = __call_result_t<__query<_Query>, _Env &, _Args...>;
 
   template <class _Env, class _Query, class... _Args>
-  concept __statically_queryable_with_impl = requires(_Query __q, _Args&&... __args) {
+  concept __statically_queryable_with_impl = requires(_Query __q, _Args &&...__args) {
     std::remove_reference_t<_Env>::query(__q, static_cast<_Args &&>(__args)...);
   };
 
diff --git a/include/stdexec/__detail/__ranges.hpp b/include/stdexec/__detail/__ranges.hpp
index caaf78d0a..2c21b6058 100644
--- a/include/stdexec/__detail/__ranges.hpp
+++ b/include/stdexec/__detail/__ranges.hpp
@@ -22,7 +22,8 @@
 
 #  include <ranges>
 
-namespace STDEXEC::ranges {
+namespace STDEXEC::ranges
+{
   using std::ranges::begin;
   using std::ranges::end;
 
@@ -30,7 +31,7 @@ namespace STDEXEC::ranges {
   using std::ranges::range_reference_t;
   using std::ranges::iterator_t;
   using std::ranges::sentinel_t;
-}
+}  // namespace STDEXEC::ranges
 
 #else
 
diff --git a/include/stdexec/__detail/__schedulers.hpp b/include/stdexec/__detail/__schedulers.hpp
index bc76892b1..d27190a25 100644
--- a/include/stdexec/__detail/__schedulers.hpp
+++ b/include/stdexec/__detail/__schedulers.hpp
@@ -34,7 +34,7 @@ namespace STDEXEC
   /////////////////////////////////////////////////////////////////////////////
   // [exec.schedule]
   template <class _Scheduler>
-  concept __has_schedule_member = requires(_Scheduler&& __sched) {
+  concept __has_schedule_member = requires(_Scheduler &&__sched) {
     static_cast<_Scheduler &&>(__sched).schedule();
   };
 
@@ -43,25 +43,25 @@ namespace STDEXEC
     template <class _Scheduler>
       requires __has_schedule_member<_Scheduler>
     STDEXEC_ATTRIBUTE(host, device, always_inline)
-    auto operator()(_Scheduler&& __sched) const
-      noexcept(noexcept(static_cast<_Scheduler&&>(__sched).schedule()))
-        -> decltype(static_cast<_Scheduler&&>(__sched).schedule())
+    auto operator()(_Scheduler &&__sched) const
+      noexcept(noexcept(static_cast<_Scheduler &&>(__sched).schedule()))
+        -> decltype(static_cast<_Scheduler &&>(__sched).schedule())
     {
-      static_assert(sender<decltype(static_cast<_Scheduler&&>(__sched).schedule())>,
+      static_assert(sender<decltype(static_cast<_Scheduler &&>(__sched).schedule())>,
                     "schedule() member functions must return a sender");
-      return static_cast<_Scheduler&&>(__sched).schedule();
+      return static_cast<_Scheduler &&>(__sched).schedule();
     }
 
     template <class _Scheduler>
       requires __has_schedule_member<_Scheduler> || __tag_invocable<schedule_t, _Scheduler>
     [[deprecated("the use of tag_invoke for schedule is deprecated")]]
     STDEXEC_ATTRIBUTE(host, device, always_inline)  //
-      auto operator()(_Scheduler&& __sched) const
+      auto operator()(_Scheduler &&__sched) const
       noexcept(__nothrow_tag_invocable<schedule_t, _Scheduler>)
         -> __tag_invoke_result_t<schedule_t, _Scheduler>
     {
       static_assert(sender<__tag_invoke_result_t<schedule_t, _Scheduler>>);
-      return __tag_invoke(*this, static_cast<_Scheduler&&>(__sched));
+      return __tag_invoke(*this, static_cast<_Scheduler &&>(__sched));
     }
 
     static constexpr auto query(forwarding_query_t) noexcept -> bool
@@ -84,7 +84,7 @@ namespace STDEXEC
   using schedule_result_t = __call_result_t<schedule_t, _Scheduler>;
 
   template <class _SchedulerProvider>
-  concept __scheduler_provider = requires(_SchedulerProvider const & __sp) {
+  concept __scheduler_provider = requires(_SchedulerProvider const &__sp) {
     { get_scheduler(__sp) } -> scheduler;
   };
 
@@ -154,7 +154,7 @@ namespace STDEXEC
     {
       template <class _Attrs, class _GetComplSch = get_completion_scheduler_t>
         requires __queryable_with<_Attrs, _GetComplSch>
-      constexpr auto operator()(_Attrs const & __attrs, __ignore = {}) const noexcept
+      constexpr auto operator()(_Attrs const &__attrs, __ignore = {}) const noexcept
         -> __decay_t<__query_result_t<_Attrs, _GetComplSch>>
       {
         static_assert(noexcept(__attrs.query(_GetComplSch{})));
@@ -164,7 +164,7 @@ namespace STDEXEC
 
       template <class _Attrs, class _Env, class _GetComplSch = get_completion_scheduler_t>
         requires __queryable_with<_Attrs, _GetComplSch, _Env const &>
-      constexpr auto operator()(_Attrs const & __attrs, _Env const & __env) const noexcept
+      constexpr auto operator()(_Attrs const &__attrs, _Env const &__env) const noexcept
         -> __decay_t<__query_result_t<_Attrs, _GetComplSch, _Env const &>>
       {
         static_assert(noexcept(__attrs.query(_GetComplSch{}, __env)));
@@ -181,7 +181,7 @@ namespace STDEXEC
     struct __recurse_query_t
     {
       template <class _Self = __recurse_query_t, class _Sch, class... _Env>
-      constexpr auto operator()([[maybe_unused]] _Sch __sch, _Env const &... __env) const noexcept
+      constexpr auto operator()([[maybe_unused]] _Sch __sch, _Env const &...__env) const noexcept
       {
         static_assert(scheduler<_Sch>);
         // When determining where the scheduler's operations will complete, we query
@@ -273,7 +273,7 @@ namespace STDEXEC
     template <class _Attrs,
               class... _Env,
               auto _DeclFn = __get_declfn<_Attrs const &, _Env const &...>()>
-    constexpr auto operator()(_Attrs const & __attrs, _Env const &... __env) const noexcept
+    constexpr auto operator()(_Attrs const &__attrs, _Env const &...__env) const noexcept
       -> __unless_one_of_t<decltype(_DeclFn()), void>
     {
       // If __attrs has a completion scheduler, then return it (after checking the scheduler
@@ -354,7 +354,7 @@ namespace STDEXEC
   template <class _Tag, sender _Sender, class... _Env>
     requires __sends<_Tag, _Sender, _Env...>
   using __completion_scheduler_of_t =
-    __call_result_t<get_completion_scheduler_t<_Tag>, env_of_t<_Sender>, const _Env&...>;
+    __call_result_t<get_completion_scheduler_t<_Tag>, env_of_t<_Sender>, const _Env &...>;
 
   // TODO(ericniebler): examine all uses of this struct.
   template <class _Scheduler>
@@ -363,7 +363,7 @@ namespace STDEXEC
     template <class... _Env>
     STDEXEC_ATTRIBUTE(nodiscard, always_inline, host, device)
     constexpr auto query(get_completion_scheduler_t<set_value_t>,
-                         _Env const &... __env) const noexcept
+                         _Env const &...__env) const noexcept
       -> __call_result_t<get_completion_scheduler_t<set_value_t>, _Scheduler, _Env const &...>
     {
       return get_completion_scheduler<set_value_t>(__sched_, __env...);
@@ -411,7 +411,7 @@ namespace STDEXEC
   struct __mk_sch_env_t
   {
     template <class _Sch, class... _Env>
-    constexpr auto operator()([[maybe_unused]] _Sch __sch, _Env const &... __env) const noexcept
+    constexpr auto operator()([[maybe_unused]] _Sch __sch, _Env const &...__env) const noexcept
     {
       if constexpr (__completes_inline<set_value_t, env_of_t<schedule_result_t<_Sch>>, _Env...>
                     && (__callable<get_scheduler_t, _Env const &> || ...))
@@ -443,11 +443,11 @@ namespace STDEXEC
                                 && __infallible_sender<__result_of<schedule, _Scheduler>, _Env...>;
 
   // Deprecated interfaces
-  using get_delegatee_scheduler_t [[deprecated("get_delegatee_scheduler_t has been renamed "
-                                               "get_delegation_scheduler_t")]] =
-    get_delegation_scheduler_t;
+  using get_delegatee_scheduler_t
+    [[deprecated("get_delegatee_scheduler_t has been renamed "
+                 "get_delegation_scheduler_t")]] = get_delegation_scheduler_t;
 
-  inline constexpr auto& get_delegatee_scheduler [[deprecated("get_delegatee_scheduler has been "
+  inline constexpr auto &get_delegatee_scheduler [[deprecated("get_delegatee_scheduler has been "
                                                               "renamed get_delegation_scheduler")]]
   = get_delegation_scheduler;
 }  // namespace STDEXEC
diff --git a/include/stdexec/__detail/__transform_completion_signatures.hpp b/include/stdexec/__detail/__transform_completion_signatures.hpp
index a6e6d0e19..480c94fe9 100644
--- a/include/stdexec/__detail/__transform_completion_signatures.hpp
+++ b/include/stdexec/__detail/__transform_completion_signatures.hpp
@@ -64,18 +64,18 @@ namespace STDEXEC
 
     template <class _Sig, template <class...> class _Tuple>
     using __for_each_sig_t = decltype(__cmplsigs::__for_each_sig<_Tuple>(
-      static_cast<_Sig*>(nullptr)));
+      static_cast<_Sig *>(nullptr)));
 
     template <template <class...> class _Tuple,
               template <class...> class _Variant,
               class... _More,
               class... _What>
-    constexpr auto __for_each_completion_signature_fn(_ERROR_<_What...>**) -> _ERROR_<_What...>;
+    constexpr auto __for_each_completion_signature_fn(_ERROR_<_What...> **) -> _ERROR_<_What...>;
     template <template <class...> class _Tuple,
               template <class...> class _Variant,
               class... _More,
               class... _Sigs>
-    constexpr auto __for_each_completion_signature_fn(completion_signatures<_Sigs...>**)
+    constexpr auto __for_each_completion_signature_fn(completion_signatures<_Sigs...> **)
       -> _Variant<__for_each_sig_t<_Sigs, _Tuple>..., _More...>;
   }  // namespace __cmplsigs
 
@@ -85,7 +85,7 @@ namespace STDEXEC
             class... _More>
   using __for_each_completion_signature_t =
     decltype(__cmplsigs::__for_each_completion_signature_fn<_Tuple, _Variant, _More...>(
-      static_cast<_Sigs**>(nullptr)));
+      static_cast<_Sigs **>(nullptr)));
 
   namespace __cmplsigs
   {
@@ -110,7 +110,7 @@ namespace STDEXEC
               template <class...> class _SetErr,
               class _SetStp>
     using __transform_sig_t = decltype(__cmplsigs::__transform_sig<_SetVal, _SetErr, _SetStp>(
-      static_cast<_Sig*>(nullptr)));
+      static_cast<_Sig *>(nullptr)));
 
     template <template <class...> class _SetVal,
               template <class...> class _SetErr,
@@ -118,7 +118,7 @@ namespace STDEXEC
               template <class...> class _Variant,
               class... _More,
               class... _What>
-    constexpr auto __transform_sigs_fn(_ERROR_<_What...>**) -> _ERROR_<_What...>;
+    constexpr auto __transform_sigs_fn(_ERROR_<_What...> **) -> _ERROR_<_What...>;
 
     template <template <class...> class _SetVal,
               template <class...> class _SetErr,
@@ -126,7 +126,7 @@ namespace STDEXEC
               template <class...> class _Variant,
               class... _More,
               class... _Sigs>
-    constexpr auto __transform_sigs_fn(completion_signatures<_Sigs...>**)
+    constexpr auto __transform_sigs_fn(completion_signatures<_Sigs...> **)
       -> _Variant<__transform_sig_t<_Sigs, _SetVal, _SetErr, _SetStp>..., _More...>;
   }  // namespace __cmplsigs
 
@@ -138,7 +138,7 @@ namespace STDEXEC
             class... _More>
   using __transform_completion_signatures_t =
     decltype(__cmplsigs::__transform_sigs_fn<_SetVal, _SetErr, _SetStp, _Variant, _More...>(
-      static_cast<_Sigs**>(nullptr)));
+      static_cast<_Sigs **>(nullptr)));
 
   namespace __cmplsigs
   {
@@ -328,14 +328,14 @@ namespace STDEXEC
     template <class _SetTag, class... _Args, class _Fn>
     [[nodiscard]]
     consteval auto
-    __transform_expr(_Fn const & __fn) -> __transform_result_t<_Fn const &, _SetTag, _Args...>
+    __transform_expr(_Fn const &__fn) -> __transform_result_t<_Fn const &, _SetTag, _Args...>
     {
       return __fn.template operator()<_SetTag, _Args...>();
     }
 
     template <class _Fn>
     [[nodiscard]]
-    consteval auto __transform_expr(_Fn const & __fn) -> __call_result_t<_Fn const &>
+    consteval auto __transform_expr(_Fn const &__fn) -> __call_result_t<_Fn const &>
     {
       return __fn();
     }
@@ -347,7 +347,7 @@ namespace STDEXEC
     // transform_completion_signatures:
     template <class... _Args, class _Fn>
     [[nodiscard]]
-    consteval auto __apply_transform(_Fn const & __fn)
+    consteval auto __apply_transform(_Fn const &__fn)
     {
       if constexpr (__minvocable_q<__transform_expr_t, _Fn, _Args...>)
       {
@@ -409,7 +409,7 @@ namespace STDEXEC
 
       template <class... Sigs>
       [[nodiscard]]
-      consteval auto operator()(Sigs*... sigs) const
+      consteval auto operator()(Sigs *...sigs) const
       {
         return __concat_completion_signatures(__tfx1(sigs)...);
       }
diff --git a/test/exec/asio/test_asio_thread_pool.cpp b/test/exec/asio/test_asio_thread_pool.cpp
index d65249d01..19f7abb85 100644
--- a/test/exec/asio/test_asio_thread_pool.cpp
+++ b/test/exec/asio/test_asio_thread_pool.cpp
@@ -31,17 +31,17 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   // Example adapted from
   // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2300r5.html#example-async-inclusive-scan
   [[nodiscard]]
-  auto async_inclusive_scan(
-    ex::scheduler auto sch,                    // 2
-    std::span<const double> input,             // 1
-    std::span<double> output,                  // 1
-    double init,                               // 1
-    std::size_t tile_count) -> ex::sender auto // 3
+  auto async_inclusive_scan(ex::scheduler auto      sch,                // 2
+                            std::span<double const> input,              // 1
+                            std::span<double>       output,             // 1
+                            double                  init,               // 1
+                            std::size_t             tile_count) -> ex::sender auto  // 3
   {
     using namespace STDEXEC;
     std::size_t const tile_size = (input.size() + tile_count - 1) / tile_count;
@@ -49,33 +49,34 @@ namespace {
     std::vector<double> partials(tile_count + 1);
     partials[0] = init;
 
-    return just(std::move(partials)) | continues_on(sch) //
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               partials[i + 1] = *--std::inclusive_scan(
-                 begin(input) + static_cast<long>(start),
-                 begin(input) + static_cast<long>(end),
-                 begin(output) + static_cast<long>(start));
-             }) //
-         | then([](std::vector<double>&& partials) {
-             std::inclusive_scan(begin(partials), end(partials), begin(partials));
-             return std::move(partials);
-           }) //
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<const double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               std::for_each(
-                 begin(output) + static_cast<long>(start),
-                 begin(output) + static_cast<long>(end),
-                 [&](double& e) { e = partials[i] + e; });
-             }) //
+    return just(std::move(partials)) | continues_on(sch)  //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double> partials)
+                {
+                  auto start      = i * tile_size;
+                  auto end        = (std::min) (input.size(), (i + 1) * tile_size);
+                  partials[i + 1] = *--std::inclusive_scan(begin(input) + static_cast<long>(start),
+                                                           begin(input) + static_cast<long>(end),
+                                                           begin(output)
+                                                             + static_cast<long>(start));
+                })  //
+         | then(
+             [](std::vector<double>&& partials)
+             {
+               std::inclusive_scan(begin(partials), end(partials), begin(partials));
+               return std::move(partials);
+             })  //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double const> partials)
+                {
+                  auto start = i * tile_size;
+                  auto end   = (std::min) (input.size(), (i + 1) * tile_size);
+                  std::for_each(begin(output) + static_cast<long>(start),
+                                begin(output) + static_cast<long>(end),
+                                [&](double& e) { e = partials[i] + e; });
+                })  //
          | then([=](std::vector<double>&&) { return output; });
   }
 
@@ -83,17 +84,17 @@ namespace {
             "[asio_thread_pool]")
   {
     exec::asio::asio_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    CHECK(
-      ex::get_forward_progress_guarantee(pool_sched) == ex::forward_progress_guarantee::parallel);
+    auto                         pool_sched = pool.get_scheduler();
+    CHECK(ex::get_forward_progress_guarantee(pool_sched)
+          == ex::forward_progress_guarantee::parallel);
   }
 
   TEST_CASE("ex::on works when changing threads with exec::asio::asio_thread_pool",
             "[asio_thread_pool]")
   {
     exec::asio::asio_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    bool called{false};
+    auto                         pool_sched = pool.get_scheduler();
+    bool                         called{false};
     // launch some work on the thread pool
     ex::sender auto snd = ex::on(pool_sched, ex::just()) | ex::then([&] { called = true; });
     ex::sync_wait(std::move(snd));
@@ -101,12 +102,13 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE("more asio_thread_pool", "[asio_thread_pool]") {
+  TEST_CASE("more asio_thread_pool", "[asio_thread_pool]")
+  {
     using namespace STDEXEC;
 
     exec::asio::asio_thread_pool pool(1ul);
-    exec::static_thread_pool other_pool(1);
-    STDEXEC::inline_scheduler inline_sched;
+    exec::static_thread_pool     other_pool(1);
+    STDEXEC::inline_scheduler    inline_sched;
 
     // Get a handle to the thread pool:
     auto other_sched = other_pool.get_scheduler();
@@ -114,7 +116,8 @@ namespace {
     // Get a handle to the thread pool:
     auto taskflow_sched = pool.get_scheduler();
 
-    auto compute = [](int x) -> int {
+    auto compute = [](int x) -> int
+    {
       return x + 1;
     };
 
@@ -133,50 +136,50 @@ namespace {
     CHECK(k == 5);
   }
 
-  TEST_CASE("asio_thread_pool exceptions", "[asio_thread_pool]") {
+  TEST_CASE("asio_thread_pool exceptions", "[asio_thread_pool]")
+  {
     using namespace STDEXEC;
 
     exec::asio::asio_thread_pool taskflow_pool;
-    exec::static_thread_pool other_pool(1ul);
+    exec::static_thread_pool     other_pool(1ul);
     {
-      CHECK_THROWS(ex::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0)) | then([](auto) {
-                                   throw std::exception();
-                                 })));
-      CHECK_THROWS(ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0)) | then([](auto) {
-                                   throw std::exception();
-                                 })));
+      CHECK_THROWS(ex::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0))
+                                 | then([](auto) { throw std::exception(); })));
+      CHECK_THROWS(ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                 | then([](auto) { throw std::exception(); })));
     }
     // Ensure it still works normally after exceptions:
     {
-      auto tbb_result = ex::sync_wait(
-        starts_on(taskflow_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto tbb_result = ex::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0))
+                                      | then([](auto i) { return i + 1; }));
       CHECK(tbb_result.has_value());
-      auto other_result = ex::sync_wait(
-        starts_on(other_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto other_result = ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                        | then([](auto i) { return i + 1; }));
       CHECK(tbb_result == other_result);
     }
   }
 
-  TEST_CASE("asio_thread_pool async_inclusive_scan", "[asio_thread_pool]") {
-    const auto input = std::array{1.0, 2.0, -1.0, -2.0};
+  TEST_CASE("asio_thread_pool async_inclusive_scan", "[asio_thread_pool]")
+  {
+    auto const                           input = std::array{1.0, 2.0, -1.0, -2.0};
     std::remove_const_t<decltype(input)> output;
     exec::asio::asio_thread_pool         pool{2ul};
-    auto [value] = ex::sync_wait(async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4))
-                     .value();
+    auto [value] =
+      ex::sync_wait(async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4)).value();
     STATIC_REQUIRE(std::is_same_v<decltype(value), std::span<double>>);
     REQUIRE(value.data() == output.data());
     CHECK(output == std::array{1.0, 3.0, 2.0, 0.0});
   }
 
-  TEST_CASE("asiothreadpool with exec::asio interoperability", "[asio_thread_pool]") {
-    const auto current_thread_id = std::this_thread::get_id();
+  TEST_CASE("asiothreadpool with exec::asio interoperability", "[asio_thread_pool]")
+  {
+    auto const current_thread_id = std::this_thread::get_id();
 
     exec::asio::asio_thread_pool        pool{1ul};
     exec::asio::asio_impl::system_timer timer{pool.get_executor()};
-    const auto [other_thread_id] = ex::sync_wait(
-                                     timer.async_wait(exec::asio::use_sender)
-                                     | ex::then(
-                                       [](auto&&...) { return std::this_thread::get_id(); }))
+    auto const [other_thread_id] = ex::sync_wait(timer.async_wait(exec::asio::use_sender)
+                                                 | ex::then([](auto&&...)
+                                                            { return std::this_thread::get_id(); }))
                                      .value();
     REQUIRE(current_thread_id != other_thread_id);
 
@@ -184,4 +187,4 @@ namespace {
     exec::asio::asio_impl::query(pool.get_executor(), exec::asio::asio_impl::execution::context_t{})
       .stop();
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/asio/test_completion_token.cpp b/test/exec/asio/test_completion_token.cpp
index 61c95d947..f43eb4426 100644
--- a/test/exec/asio/test_completion_token.cpp
+++ b/test/exec/asio/test_completion_token.cpp
@@ -38,16 +38,17 @@
 using namespace STDEXEC;
 using namespace exec::asio;
 
-namespace {
+namespace
+{
 
-  static_assert(noexcept(detail::completion_token::convert<const int&>(std::declval<int&>())));
-  static_assert(noexcept(detail::completion_token::convert<const int>(std::declval<int>())));
+  static_assert(noexcept(detail::completion_token::convert<int const &>(std::declval<int&>())));
+  static_assert(noexcept(detail::completion_token::convert<int const>(std::declval<int>())));
   static_assert(
     noexcept(detail::completion_token::convert<std::string>(std::declval<std::string>())));
   static_assert(
-    !noexcept(detail::completion_token::convert<std::string>(std::declval<const std::string&>())));
+    !noexcept(detail::completion_token::convert<std::string>(std::declval<std::string const &>())));
   static_assert(
-    !noexcept(detail::completion_token::convert<std::string>(std::declval<const char*>())));
+    !noexcept(detail::completion_token::convert<std::string>(std::declval<char const *>())));
 
   //  connect_shared and start_shared ensure the operation state's lifetime ends
   //  within the completion signal handling of the receiver thereby ensuring any
@@ -55,12 +56,14 @@ namespace {
   //  signal is caught be AddressSanitizer
 
   template <typename Receiver>
-  class connect_shared_receiver {
-    Receiver r_;
+  class connect_shared_receiver
+  {
+    Receiver               r_;
     std::shared_ptr<void>& ptr_;
 
     template <typename Tag, typename... Args>
-    void complete_(const Tag& tag, Args&&... args) noexcept {
+    void complete_(Tag const & tag, Args&&... args) noexcept
+    {
       CHECK(ptr_);
       CHECK(ptr_.use_count() == 1);
       tag(std::move(r_), std::forward<Args>(args)...);
@@ -73,55 +76,53 @@ namespace {
       requires std::constructible_from<Receiver, T>
     constexpr explicit connect_shared_receiver(T&& t, std::shared_ptr<void>& ptr) noexcept
       : r_(std::forward<T>(t))
-      , ptr_(ptr) {
-    }
+      , ptr_(ptr)
+    {}
 
     constexpr void set_stopped() && noexcept
-      requires ::STDEXEC::receiver_of<
-        Receiver,
-        ::STDEXEC::completion_signatures<::STDEXEC::set_stopped_t()>
-      >
+      requires ::STDEXEC::receiver_of<Receiver,
+                                      ::STDEXEC::completion_signatures<::STDEXEC::set_stopped_t()>>
     {
       complete_(::STDEXEC::set_stopped);
     }
 
     template <typename T>
-      requires ::STDEXEC::receiver_of<
-        Receiver,
-        ::STDEXEC::completion_signatures<::STDEXEC::set_error_t(T)>
-      >
-    constexpr void set_error(T&& t) && noexcept {
+      requires ::STDEXEC::receiver_of<Receiver,
+                                      ::STDEXEC::completion_signatures<::STDEXEC::set_error_t(T)>>
+    constexpr void set_error(T&& t) && noexcept
+    {
       complete_(::STDEXEC::set_error, std::forward<T>(t));
     }
 
     template <typename... Args>
       requires ::STDEXEC::receiver_of<
         Receiver,
-        ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(Args...)>
-      >
-    constexpr void set_value(Args&&... args) && noexcept {
+        ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(Args...)>>
+    constexpr void set_value(Args&&... args) && noexcept
+    {
       complete_(::STDEXEC::set_value, std::forward<Args>(args)...);
     }
 
-    constexpr decltype(auto) get_env() const noexcept {
+    constexpr decltype(auto) get_env() const noexcept
+    {
       return ::STDEXEC::get_env(r_);
     }
   };
 
   template <typename Sender, typename Receiver>
-  class connect_shared_operation_state {
+  class connect_shared_operation_state
+  {
     using receiver_ = connect_shared_receiver<std::remove_cvref_t<Receiver>>;
-    std::shared_ptr<void> self_;
+    std::shared_ptr<void>                          self_;
     ::STDEXEC::connect_result_t<Sender, receiver_> op_;
    public:
     constexpr explicit connect_shared_operation_state(Sender&& s, Receiver&& r)
       : op_(
-          ::STDEXEC::connect(
-            std::forward<Sender>(s),
-            receiver_(std::forward<Receiver>(r), self_))) {
-    }
+          ::STDEXEC::connect(std::forward<Sender>(s), receiver_(std::forward<Receiver>(r), self_)))
+    {}
 
-    void start(std::shared_ptr<connect_shared_operation_state>&& ptr) & noexcept {
+    void start(std::shared_ptr<connect_shared_operation_state>&& ptr) & noexcept
+    {
       CHECK(ptr.get() == this);
       CHECK(ptr.use_count() == 1);
       self_ = std::move(ptr);
@@ -130,45 +131,46 @@ namespace {
   };
 
   template <typename Sender, typename Receiver>
-  auto connect_shared(Sender&& sender, Receiver&& receiver) {
+  auto connect_shared(Sender&& sender, Receiver&& receiver)
+  {
     return std::make_shared<connect_shared_operation_state<Sender, Receiver>>(
-      std::forward<Sender>(sender), std::forward<Receiver>(receiver));
+      std::forward<Sender>(sender),
+      std::forward<Receiver>(receiver));
   }
 
   template <typename Sender, typename Receiver>
   void
-    start_shared(std::shared_ptr<connect_shared_operation_state<Sender, Receiver>>&& ptr) noexcept {
+  start_shared(std::shared_ptr<connect_shared_operation_state<Sender, Receiver>>&& ptr) noexcept
+  {
     REQUIRE(ptr);
     auto&& state = *ptr;
     state.start(std::move(ptr));
   }
 
-  TEST_CASE(
-    "Asio-based asynchronous operation ends with error when canceled",
-    "[asioexec][completion_token]") {
+  TEST_CASE("Asio-based asynchronous operation ends with error when canceled",
+            "[asioexec][completion_token]")
+  {
     inplace_stop_source source;
 
-    const struct {
-      auto query(const get_stop_token_t&) const noexcept {
+    const struct
+    {
+      auto query(get_stop_token_t const &) const noexcept
+      {
         return source_.get_token();
       }
 
       inplace_stop_source& source_;
     } e{source};
 
-    error_code err;
-    asio_impl::io_context ctx;
+    error_code              err;
+    asio_impl::io_context   ctx;
     asio_impl::system_timer t(ctx);
     t.expires_after(std::chrono::years(1));
     auto sender = t.async_wait(completion_token);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(sender), env<>>,
-                  completion_signatures<
-                    set_stopped_t(),
-                    set_error_t(std::exception_ptr),
-                    set_value_t(error_code)
-                  >
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(sender), env<>>,
+                                 completion_signatures<set_stopped_t(),
+                                                       set_error_t(std::exception_ptr),
+                                                       set_value_t(error_code)>>);
     CHECK(!ctx.poll());
     CHECK(ctx.stopped());
     ctx.restart();
@@ -184,8 +186,9 @@ namespace {
     CHECK(err == asio_impl::error::operation_aborted);
   }
 
-  TEST_CASE("Posting may be redirected to a sender", "[asioexec][completion_token]") {
-    asio_impl::io_context ctx;
+  TEST_CASE("Posting may be redirected to a sender", "[asioexec][completion_token]")
+  {
+    asio_impl::io_context   ctx;
     asio_impl::system_timer t(ctx);
     t.expires_after(std::chrono::years(1));
     auto sender = asio_impl::post(ctx.get_executor(), completion_token);
@@ -202,43 +205,48 @@ namespace {
   }
 
   template <typename CompletionToken>
-  decltype(auto) async_throw_from_initiation(CompletionToken&& token) {
+  decltype(auto) async_throw_from_initiation(CompletionToken&& token)
+  {
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [](const auto&) { throw std::logic_error("Test"); }, token);
+      [](auto const &) { throw std::logic_error("Test"); },
+      token);
   }
 
-  TEST_CASE(
-    "When initiating the asynchronous operation throws this causes the "
-    "sender to send a std::exception_ptr",
-    "[asioexec][completion_token]") {
+  TEST_CASE("When initiating the asynchronous operation throws this causes the "
+            "sender to send a std::exception_ptr",
+            "[asioexec][completion_token]")
+  {
     std::exception_ptr ex;
-    auto op =
-      connect_shared(async_throw_from_initiation(completion_token), expect_error_receiver_ex(ex));
+    auto               op = connect_shared(async_throw_from_initiation(completion_token),
+                             expect_error_receiver_ex(ex));
     CHECK(!ex);
     start_shared(std::move(op));
     CHECK(ex);
   }
 
   template <typename Executor, typename CompletionToken>
-  decltype(auto) async_throw_from_completion(const Executor& ex, CompletionToken&& token) {
+  decltype(auto) async_throw_from_completion(Executor const & ex, CompletionToken&& token)
+  {
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [ex](auto h) {
-        const auto assoc = asio_impl::get_associated_executor(h, ex);
-        asio_impl::post(ex, asio_impl::bind_executor(assoc, [h = std::move(h)]() {
-                          throw std::logic_error("Test");
-                        }));
+      [ex](auto h)
+      {
+        auto const assoc = asio_impl::get_associated_executor(h, ex);
+        asio_impl::post(ex,
+                        asio_impl::bind_executor(assoc,
+                                                 [h = std::move(h)]()
+                                                 { throw std::logic_error("Test"); }));
       },
       token);
   }
 
-  TEST_CASE(
-    "When a completion handler invoked as part of a composed "
-    "asynchronous operation throws that exception is captured and sent as a "
-    "std::exception_ptr",
-    "[asioexec][completion_token]") {
-    std::exception_ptr ex;
+  TEST_CASE("When a completion handler invoked as part of a composed "
+            "asynchronous operation throws that exception is captured and sent as a "
+            "std::exception_ptr",
+            "[asioexec][completion_token]")
+  {
+    std::exception_ptr    ex;
     asio_impl::io_context ctx;
     auto sender = async_throw_from_completion(ctx.get_executor(), completion_token);
     CHECK(!ctx.poll());
@@ -255,23 +263,25 @@ namespace {
     CHECK(ex);
   }
 
-  TEST_CASE(
-    "When an operation is abandoned this is reported via a stopped "
-    "signal",
-    "[asioexec][completion_token]") {
-    bool stopped = false;
+  TEST_CASE("When an operation is abandoned this is reported via a stopped "
+            "signal",
+            "[asioexec][completion_token]")
+  {
+    bool                       stopped = false;
     expect_stopped_receiver_ex r(stopped);
-    using sender_type = decltype(std::declval<asio_impl::system_timer&>()
-                                   .async_wait(completion_token));
+    using sender_type          = decltype(std::declval<asio_impl::system_timer&>().async_wait(
+      completion_token));
     using operation_state_type = connect_result_t<sender_type, decltype(r)>;
     std::optional<operation_state_type> op;
     {
-      asio_impl::io_context ctx;
+      asio_impl::io_context   ctx;
       asio_impl::system_timer t(ctx);
       t.expires_after(std::chrono::years(1));
 
-      struct {
-        operator operation_state_type() {
+      struct
+      {
+        operator operation_state_type()
+        {
           return ::STDEXEC::connect(std::move(s_), std::move(r_));
         }
 
@@ -287,30 +297,34 @@ namespace {
   }
 
   template <typename Executor, typename CompletionToken>
-  decltype(auto) async_indirect_completion_handler(
-    const Executor& ex,
-    std::shared_ptr<void>& ptr,
-    CompletionToken&& token) {
+  decltype(auto) async_indirect_completion_handler(Executor const &       ex,
+                                                   std::shared_ptr<void>& ptr,
+                                                   CompletionToken&&      token)
+  {
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [&ptr](auto h, const auto& ex) {
-        auto local = std::make_shared<decltype(h)>(std::move(h));
-        const auto assoc = asio_impl::get_associated_executor(*local, ex);
-        ptr = local;
-        asio_impl::post(ex, asio_impl::bind_executor(assoc, [local]() mutable {
-                          std::invoke(std::move(*local));
-                          local.reset();
-                        }));
+      [&ptr](auto h, auto const & ex)
+      {
+        auto       local = std::make_shared<decltype(h)>(std::move(h));
+        auto const assoc = asio_impl::get_associated_executor(*local, ex);
+        ptr              = local;
+        asio_impl::post(ex,
+                        asio_impl::bind_executor(assoc,
+                                                 [local]() mutable
+                                                 {
+                                                   std::invoke(std::move(*local));
+                                                   local.reset();
+                                                 }));
       },
       token,
       ex);
   }
 
-  TEST_CASE(
-    "If the completion handler outlives completion of the operation "
-    "the receiver contract is still satisfied eagerly",
-    "[asioexec][completion_token]") {
-    bool invoked = false;
+  TEST_CASE("If the completion handler outlives completion of the operation "
+            "the receiver contract is still satisfied eagerly",
+            "[asioexec][completion_token]")
+  {
+    bool                  invoked = false;
     std::shared_ptr<void> ptr;
     asio_impl::io_context ctx;
     auto sender = async_indirect_completion_handler(ctx.get_executor(), ptr, completion_token);
@@ -333,10 +347,10 @@ namespace {
   }
 
   template <typename Executor, typename CompletionToken>
-  decltype(auto) async_indirect_completion_handler_throw_from_completion(
-    const Executor& ex,
-    std::shared_ptr<void>& ptr,
-    CompletionToken&& token) {
+  decltype(auto) async_indirect_completion_handler_throw_from_completion(Executor const &       ex,
+                                                                         std::shared_ptr<void>& ptr,
+                                                                         CompletionToken&& token)
+  {
     //  This function is seemingly fragile?
     //
     //  In release mode slightly different arrangements produce bizarre outcomes:
@@ -352,35 +366,39 @@ namespace {
     //    -1564306560 == 1
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [&ptr](auto h, const auto& ex) {
-        auto local = std::make_shared<decltype(h)>(std::move(h));
-        const auto assoc = asio_impl::get_associated_executor(*local, ex);
-        ptr = local;
-        asio_impl::post(assoc, [&ptr, local = std::move(local)]() mutable {
-          CHECK(local.use_count() == 2);
-          CHECK(ptr.use_count() == 2);
-          auto cpy = std::move(local);
-          cpy.reset();
-          CHECK(ptr.use_count() == 1);
-          throw std::logic_error("Test");
-        });
+      [&ptr](auto h, auto const & ex)
+      {
+        auto       local = std::make_shared<decltype(h)>(std::move(h));
+        auto const assoc = asio_impl::get_associated_executor(*local, ex);
+        ptr              = local;
+        asio_impl::post(assoc,
+                        [&ptr, local = std::move(local)]() mutable
+                        {
+                          CHECK(local.use_count() == 2);
+                          CHECK(ptr.use_count() == 2);
+                          auto cpy = std::move(local);
+                          cpy.reset();
+                          CHECK(ptr.use_count() == 1);
+                          throw std::logic_error("Test");
+                        });
       },
       token,
       ex);
   }
 
-  TEST_CASE(
-    "If the completion handler outlives completion of the operation "
-    "satisfaction of the receiver contract is deferred until the end of the "
-    "completion handler's lifetime (this is necessary in situations where "
-    "asynchronous control flow bifurcates and one of the child operations ends "
-    "via exception)",
-    "[asioexec][completion_token]") {
-    std::exception_ptr ex;
+  TEST_CASE("If the completion handler outlives completion of the operation "
+            "satisfaction of the receiver contract is deferred until the end of the "
+            "completion handler's lifetime (this is necessary in situations where "
+            "asynchronous control flow bifurcates and one of the child operations ends "
+            "via exception)",
+            "[asioexec][completion_token]")
+  {
+    std::exception_ptr    ex;
     std::shared_ptr<void> ptr;
     asio_impl::io_context ctx;
-    auto sender = async_indirect_completion_handler_throw_from_completion(
-      ctx.get_executor(), ptr, completion_token);
+    auto sender = async_indirect_completion_handler_throw_from_completion(ctx.get_executor(),
+                                                                          ptr,
+                                                                          completion_token);
     CHECK(!ctx.poll());
     CHECK(ctx.stopped());
     ctx.restart();
@@ -401,96 +419,117 @@ namespace {
   }
 
   template <typename CompletionToken>
-  decltype(auto) async_multishot(CompletionToken&& token) {
+  decltype(auto) async_multishot(CompletionToken&& token)
+  {
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [](auto&& h) { std::forward<decltype(h)>(h)(); }, token);
+      [](auto&& h) { std::forward<decltype(h)>(h)(); },
+      token);
   }
 
-  TEST_CASE("When appropriate the yielded sender is multi-shot", "[asioexec][completion_token]") {
-    const auto sender = async_multishot(completion_token);
-    auto a = connect_shared(sender, expect_void_receiver{});
-    auto b = connect_shared(sender, expect_void_receiver{});
+  TEST_CASE("When appropriate the yielded sender is multi-shot", "[asioexec][completion_token]")
+  {
+    auto const sender = async_multishot(completion_token);
+    auto       a      = connect_shared(sender, expect_void_receiver{});
+    auto       b      = connect_shared(sender, expect_void_receiver{});
     start_shared(std::move(a));
     start_shared(std::move(b));
   }
 
   template <typename CompletionToken>
-  decltype(auto) async_single_shot(CompletionToken&& token) {
+  decltype(auto) async_single_shot(CompletionToken&& token)
+  {
     using signature_type = void();
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [ptr = std::make_unique<int>(5)](auto&& h) { std::forward<decltype(h)>(h)(); }, token);
+      [ptr = std::make_unique<int>(5)](auto&& h) { std::forward<decltype(h)>(h)(); },
+      token);
   }
 
-  TEST_CASE("When appropriate the yielded sender is single shot", "[asioexec][completion_token]") {
+  TEST_CASE("When appropriate the yielded sender is single shot", "[asioexec][completion_token]")
+  {
     auto sender = async_single_shot(completion_token);
     static_assert(!::STDEXEC::sender_to<const decltype(sender)&, expect_void_receiver<>>);
     start_shared(connect_shared(std::move(sender), expect_void_receiver{}));
   }
 
-  TEST_CASE(
-    "When an operation is abandoned by the initiating function "
-    "set_stopped is sent immediately",
-    "[asioexec][completion_token]") {
-    const auto initiating_function = [&](auto&& token) {
-      return asio_impl::async_initiate<decltype(token), void()>([](auto&&) noexcept { }, token);
+  TEST_CASE("When an operation is abandoned by the initiating function "
+            "set_stopped is sent immediately",
+            "[asioexec][completion_token]")
+  {
+    auto const initiating_function = [&](auto&& token)
+    {
+      return asio_impl::async_initiate<decltype(token), void()>([](auto&&) noexcept {}, token);
     };
     start_shared(connect_shared(initiating_function(completion_token), expect_stopped_receiver{}));
   }
 
-  class thread {
-    asio_impl::io_context ctx_;
+  class thread
+  {
+    asio_impl::io_context                                                ctx_;
     asio_impl::executor_work_guard<asio_impl::io_context::executor_type> g_;
-    std::thread t_;
+    std::thread                                                          t_;
    public:
     thread()
       : g_(ctx_.get_executor())
-      , t_([&]() noexcept {
-        STDEXEC_TRY {
-          ctx_.run();
-        }
-        STDEXEC_CATCH_ALL {
-          FAIL("Exception thrown in background thread");
-        }
-      }) {
-    }
+      , t_(
+          [&]() noexcept
+          {
+            STDEXEC_TRY
+            {
+              ctx_.run();
+            }
+            STDEXEC_CATCH_ALL
+            {
+              FAIL("Exception thrown in background thread");
+            }
+          })
+    {}
 
-    ~thread() noexcept {
+    ~thread() noexcept
+    {
       g_.reset();
-      if (t_.joinable()) {
+      if (t_.joinable())
+      {
         t_.join();
       }
     }
 
-    void join() noexcept {
+    void join() noexcept
+    {
       g_.reset();
       t_.join();
     }
 
-    asio_impl::io_context& context() noexcept {
+    asio_impl::io_context& context() noexcept
+    {
       return ctx_;
     }
   };
 
   template <typename CompletionHandler>
-  struct ping_pong {
+  struct ping_pong
+  {
     explicit ping_pong(asio_impl::io_context& a, asio_impl::io_context& b, CompletionHandler h)
       : a_(a)
       , a_g_(a.get_executor())
       , b_(b)
       , b_g_(b.get_executor())
-      , h_(std::move(h)) {
-    }
+      , h_(std::move(h))
+    {}
 
-    void operator()() && {
-      if (i_ == 10000) {
+    void operator()() &&
+    {
+      if (i_ == 10000)
+      {
         a_g_.reset();
         b_g_.reset();
         std::invoke(std::move(h_));
         return;
       }
-      const auto ex = [&]() noexcept {
-        if (i_ % 2) {
+      auto const ex = [&]() noexcept
+      {
+        if (i_ % 2)
+        {
           return a_.get_executor();
         }
         return b_.get_executor();
@@ -499,25 +538,28 @@ namespace {
       asio_impl::post(ex, std::move(*this));
     }
 
-    asio_impl::io_context& a_;
+    asio_impl::io_context&                                               a_;
     asio_impl::executor_work_guard<asio_impl::io_context::executor_type> a_g_;
-    asio_impl::io_context& b_;
+    asio_impl::io_context&                                               b_;
     asio_impl::executor_work_guard<asio_impl::io_context::executor_type> b_g_;
-    CompletionHandler h_;
-    std::size_t i_{0};
+    CompletionHandler                                                    h_;
+    std::size_t                                                          i_{0};
   };
 
-  TEST_CASE(
-    "Intermediate completion handlers being passed between threads has "
-    "no effect on the transformation of an initiating function into a sender",
-    "[asioexec][completion_token]") {
-    thread a;
-    thread b;
-    const auto initiating_function = [&](auto&& token) {
+  TEST_CASE("Intermediate completion handlers being passed between threads has "
+            "no effect on the transformation of an initiating function into a sender",
+            "[asioexec][completion_token]")
+  {
+    thread     a;
+    thread     b;
+    auto const initiating_function = [&](auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void()>(
-        [&a, &b](auto&& h) {
-          ping_pong<std::remove_cvref_t<decltype(h)>>{
-            a.context(), b.context(), std::forward<decltype(h)>(h)}();
+        [&a, &b](auto&& h)
+        {
+          ping_pong<std::remove_cvref_t<decltype(h)>>{a.context(),
+                                                      b.context(),
+                                                      std::forward<decltype(h)>(h)}();
         },
         token);
     };
@@ -526,19 +568,19 @@ namespace {
     b.join();
   }
 
-  TEST_CASE(
-    "When the initiating function posts and then throws, and the "
-    "posted operation simply abandons the completion handler, the operation "
-    "completes after the post with the thrown error",
-    "[asioexec][completion_token]") {
-    std::exception_ptr ex;
+  TEST_CASE("When the initiating function posts and then throws, and the "
+            "posted operation simply abandons the completion handler, the operation "
+            "completes after the post with the thrown error",
+            "[asioexec][completion_token]")
+  {
+    std::exception_ptr    ex;
     asio_impl::io_context ctx;
     auto const            initiating_function = [&](auto&& token)
     {
       return asio_impl::async_initiate<decltype(token), void()>(
         [&](auto h)
         {
-          asio_impl::post(ctx.get_executor(), [h = std::move(h)]() noexcept { });
+          asio_impl::post(ctx.get_executor(), [h = std::move(h)]() noexcept {});
           throw std::logic_error("Test");
         },
         token);
@@ -554,25 +596,31 @@ namespace {
     CHECK(ex);
   }
 
-  TEST_CASE(
-    "When there are two parallel paths of asynchronous execution, and "
-    "one of them throws an exception, and the other is abandoned, the "
-    "operation completes with the thrown exception",
-    "[asioexec][completion_token]") {
-    for (unsigned u = 0; u < 2; ++u) {
-      std::exception_ptr ex;
+  TEST_CASE("When there are two parallel paths of asynchronous execution, and "
+            "one of them throws an exception, and the other is abandoned, the "
+            "operation completes with the thrown exception",
+            "[asioexec][completion_token]")
+  {
+    for (unsigned u = 0; u < 2; ++u)
+    {
+      std::exception_ptr    ex;
       asio_impl::io_context ctx;
-      const auto initiating_function = [&](auto&& token) {
+      auto const            initiating_function = [&](auto&& token)
+      {
         return asio_impl::async_initiate<decltype(token), void()>(
-          [&](auto&& h) {
+          [&](auto&& h)
+          {
             auto ptr = std::make_shared<std::remove_cvref_t<decltype(h)>>(
               std::forward<decltype(h)>(h));
-            const auto ex = asio_impl::get_associated_executor(*ptr, ctx.get_executor());
-            if (u) {
+            auto const ex = asio_impl::get_associated_executor(*ptr, ctx.get_executor());
+            if (u)
+            {
               asio_impl::post(ex, [ptr]() { throw std::logic_error("Test"); });
-              asio_impl::post(ex, [ptr = std::move(ptr)]() noexcept { });
-            } else {
-              asio_impl::post(ex, [ptr]() noexcept { });
+              asio_impl::post(ex, [ptr = std::move(ptr)]() noexcept {});
+            }
+            else
+            {
+              asio_impl::post(ex, [ptr]() noexcept {});
               asio_impl::post(ex, [ptr = std::move(ptr)]() { throw std::logic_error("Test"); });
             }
           },
@@ -593,83 +641,96 @@ namespace {
     }
   }
 
-  TEST_CASE(
-    "When the Asio signature suggests the operation will send an "
-    "rvalue, but a const lvalue is sent, and the decay-copy throws, that "
-    "exception is sent as an error in completing the operation",
-    "[asioexec][completion_token]") {
-    class obj {
+  TEST_CASE("When the Asio signature suggests the operation will send an "
+            "rvalue, but a const lvalue is sent, and the decay-copy throws, that "
+            "exception is sent as an error in completing the operation",
+            "[asioexec][completion_token]")
+  {
+    class obj
+    {
       bool throw_;
      public:
       explicit obj(bool t = false) noexcept
-        : throw_(t) {
-      }
+        : throw_(t)
+      {}
 
       obj(obj&&) = default;
 
-      obj(const obj& other)
-        : throw_(other.throw_) {
-        if (throw_) {
+      obj(obj const & other)
+        : throw_(other.throw_)
+      {
+        if (throw_)
+        {
           throw std::logic_error("Test");
         }
       }
 
-      obj& operator=(const obj&) = delete;
+      obj& operator=(obj const &) = delete;
 
-      bool operator==(const obj& rhs) const noexcept {
+      bool operator==(obj const & rhs) const noexcept
+      {
         return throw_ == rhs.throw_;
       }
     };
 
-    const obj expected;
+    obj const          expected;
     std::exception_ptr ex;
-    const auto initiating_function = [](obj o, auto&& token) {
+    auto const         initiating_function = [](obj o, auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void(obj)>(
-        [o = std::move(o)](auto&& h) {
+        [o = std::move(o)](auto&& h)
+        {
           //  Lambda isn't mutable and there's no std::move so o's type is
           //  const obj&
           std::invoke(std::forward<decltype(h)>(h), o);
         },
         token);
     };
-    auto a =
-      connect_shared(initiating_function(obj{}, completion_token), expect_value_receiver(expected));
-    auto b = connect_shared(
-      initiating_function(obj(true), completion_token), expect_error_receiver_ex(ex));
+    auto a = connect_shared(initiating_function(obj{}, completion_token),
+                            expect_value_receiver(expected));
+    auto b = connect_shared(initiating_function(obj(true), completion_token),
+                            expect_error_receiver_ex(ex));
     start_shared(std::move(a));
     CHECK(!ex);
     start_shared(std::move(b));
     CHECK(ex);
   }
 
-  struct value_category_receiver {
+  struct value_category_receiver
+  {
     using receiver_concept = receiver_t;
 
-    void set_value(std::mutex&&) && noexcept {
+    void set_value(std::mutex&&) && noexcept
+    {
       CHECK(kind_ == kind::none);
       kind_ = kind::rvalue;
     }
 
-    void set_value(std::mutex&) && noexcept {
+    void set_value(std::mutex&) && noexcept
+    {
       CHECK(kind_ == kind::none);
       kind_ = kind::mutable_lvalue;
     }
 
-    void set_value(const std::mutex&) && noexcept {
+    void set_value(std::mutex const &) && noexcept
+    {
       CHECK(kind_ == kind::none);
       kind_ = kind::const_lvalue;
     }
 
-    void set_error(std::exception_ptr) && noexcept {
+    void set_error(std::exception_ptr) && noexcept
+    {
       CHECK(kind_ == kind::none);
       kind_ = kind::error;
     }
 
-    void set_stopped() && noexcept {
+    void set_stopped() && noexcept
+    {
       CHECK(kind_ == kind::none);
       kind_ = kind::stopped;
     }
-    enum class kind {
+    enum class kind
+    {
       none,
       rvalue,
       mutable_lvalue,
@@ -679,23 +740,28 @@ namespace {
     };
 
     constexpr explicit value_category_receiver(kind& k) noexcept
-      : kind_(k) {
-    }
+      : kind_(k)
+    {}
    private:
     kind& kind_;
   };
 
-  TEST_CASE(
-    "When the operation declares separate rvalue and lvalue completion signatures they are "
-    "appropriately passed through",
-    "[asioexec][completion_token]") {
-    const auto initiating_function = [](const bool rvalue, auto&& token) {
+  TEST_CASE("When the operation declares separate rvalue and lvalue completion signatures they are "
+            "appropriately passed through",
+            "[asioexec][completion_token]")
+  {
+    auto const initiating_function = [](bool const rvalue, auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void(std::mutex&&), void(std::mutex&)>(
-        [rvalue](auto&& h) {
+        [rvalue](auto&& h)
+        {
           std::mutex m;
-          if (rvalue) {
+          if (rvalue)
+          {
             std::invoke(std::forward<decltype(h)>(h), std::move(m));
-          } else {
+          }
+          else
+          {
             std::invoke(std::forward<decltype(h)>(h), m);
           }
         },
@@ -703,10 +769,10 @@ namespace {
     };
     value_category_receiver::kind rvalue_kind{value_category_receiver::kind::none};
     value_category_receiver::kind lvalue_kind{value_category_receiver::kind::none};
-    auto rvalue = connect_shared(
-      initiating_function(true, completion_token), value_category_receiver(rvalue_kind));
-    auto lvalue = connect_shared(
-      initiating_function(false, completion_token), value_category_receiver(lvalue_kind));
+    auto rvalue = connect_shared(initiating_function(true, completion_token),
+                                 value_category_receiver(rvalue_kind));
+    auto lvalue = connect_shared(initiating_function(false, completion_token),
+                                 value_category_receiver(lvalue_kind));
     CHECK(rvalue_kind == value_category_receiver::kind::none);
     start_shared(std::move(rvalue));
     CHECK(rvalue_kind == value_category_receiver::kind::rvalue);
@@ -715,17 +781,25 @@ namespace {
     CHECK(lvalue_kind == value_category_receiver::kind::mutable_lvalue);
   }
 
-  TEST_CASE(
-    "When the operation declares separate rvalue and const lvalue completion signatures they are "
-    "appropriately passed through even if the lvalue is sent mutable",
-    "[asioexec][completion_token]") {
-    const auto initiating_function = [](const bool rvalue, auto&& token) {
-      return asio_impl::async_initiate<decltype(token), void(std::mutex&&), void(const std::mutex&)>(
-        [rvalue](auto&& h) {
+  TEST_CASE("When the operation declares separate rvalue and const lvalue completion signatures "
+            "they are "
+            "appropriately passed through even if the lvalue is sent mutable",
+            "[asioexec][completion_token]")
+  {
+    auto const initiating_function = [](bool const rvalue, auto&& token)
+    {
+      return asio_impl::async_initiate<decltype(token),
+                                       void(std::mutex&&),
+                                       void(std::mutex const &)>(
+        [rvalue](auto&& h)
+        {
           std::mutex m;
-          if (rvalue) {
+          if (rvalue)
+          {
             std::invoke(std::forward<decltype(h)>(h), std::move(m));
-          } else {
+          }
+          else
+          {
             std::invoke(std::forward<decltype(h)>(h), m);
           }
         },
@@ -733,10 +807,10 @@ namespace {
     };
     value_category_receiver::kind rvalue_kind{value_category_receiver::kind::none};
     value_category_receiver::kind lvalue_kind{value_category_receiver::kind::none};
-    auto rvalue = connect_shared(
-      initiating_function(true, completion_token), value_category_receiver(rvalue_kind));
-    auto lvalue = connect_shared(
-      initiating_function(false, completion_token), value_category_receiver(lvalue_kind));
+    auto rvalue = connect_shared(initiating_function(true, completion_token),
+                                 value_category_receiver(rvalue_kind));
+    auto lvalue = connect_shared(initiating_function(false, completion_token),
+                                 value_category_receiver(lvalue_kind));
     CHECK(rvalue_kind == value_category_receiver::kind::none);
     start_shared(std::move(rvalue));
     CHECK(rvalue_kind == value_category_receiver::kind::rvalue);
@@ -745,54 +819,64 @@ namespace {
     CHECK(lvalue_kind == value_category_receiver::kind::const_lvalue);
   }
 
-  TEST_CASE(
-    "Lvalue invocation of the completion handler is supported (for compatibility with Boost.Beast "
-    "perhaps among others)",
-    "[asioexec][completion_token]") {
-    const auto initiating_function = [](auto&& token) {
+  TEST_CASE("Lvalue invocation of the completion handler is supported (for compatibility with "
+            "Boost.Beast "
+            "perhaps among others)",
+            "[asioexec][completion_token]")
+  {
+    auto const initiating_function = [](auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void()>([](auto&& h) { h(); }, token);
     };
     auto op = ::STDEXEC::connect(initiating_function(completion_token), expect_value_receiver{});
     ::STDEXEC::start(op);
   }
 
-  TEST_CASE(
-    "Cancellation is delivered thread safely even when emitted thread unsafely",
-    "[asioexec][use_sender]") {
-    bool cancelled = false;
-    bool thread_safe = false;
-    std::mutex m;
+  TEST_CASE("Cancellation is delivered thread safely even when emitted thread unsafely",
+            "[asioexec][use_sender]")
+  {
+    bool                  cancelled   = false;
+    bool                  thread_safe = false;
+    std::mutex            m;
     asio_impl::io_context ctx;
-    std::barrier barrier(2);
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    std::barrier          barrier(2);
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept {
-            const std::unique_lock l(m, std::try_to_lock);
-            thread_safe = bool(l);
-            cancelled = true;
-          });
-          const auto ex = asio_impl::get_associated_executor(h, ctx.get_executor());
-          asio_impl::post(ex, [&, h = std::move(h)]() mutable {
-            auto local = std::move(h);
-            (void) local;
-            const std::lock_guard l(m);
-            barrier.arrive_and_wait();
-            std::this_thread::sleep_for(std::chrono::milliseconds(50));
-          });
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign(
+            [&](auto&&...) noexcept
+            {
+              std::unique_lock const l(m, std::try_to_lock);
+              thread_safe = bool(l);
+              cancelled   = true;
+            });
+          auto const ex = asio_impl::get_associated_executor(h, ctx.get_executor());
+          asio_impl::post(ex,
+                          [&, h = std::move(h)]() mutable
+                          {
+                            auto local = std::move(h);
+                            (void) local;
+                            std::lock_guard const l(m);
+                            barrier.arrive_and_wait();
+                            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                          });
         },
         token);
     };
     ::STDEXEC::inplace_stop_source source;
-    auto sender = initiating_function(completion_token);
+    auto                           sender = initiating_function(completion_token);
     {
-      auto ptr = connect_shared(
-        std::move(sender),
-        expect_stopped_receiver(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
-      std::thread t([&]() noexcept {
-        barrier.arrive_and_wait();
-        source.request_stop();
-      });
+      auto        ptr = connect_shared(std::move(sender),
+                                expect_stopped_receiver(
+                                  ::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
+      std::thread t(
+        [&]() noexcept
+        {
+          barrier.arrive_and_wait();
+          source.request_stop();
+        });
       start_shared(std::move(ptr));
       CHECK(ctx.run() != 0);
       //  Just in case
@@ -803,24 +887,27 @@ namespace {
     }
   }
 
-  TEST_CASE("Upon completion the stop token is no longer in use", "[asioexec][use_sender]") {
-    bool cancelled = false;
+  TEST_CASE("Upon completion the stop token is no longer in use", "[asioexec][use_sender]")
+  {
+    bool                           cancelled = false;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h)
-            .assign([&](auto&&...) noexcept { cancelled = true; });
-          const auto ex = asio_impl::get_associated_executor(h, ctx.get_executor());
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept
+                                                                { cancelled = true; });
+          auto const ex = asio_impl::get_associated_executor(h, ctx.get_executor());
           asio_impl::post(ex, std::move(h));
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto op = ::STDEXEC::connect(
-      std::move(sender),
-      expect_void_receiver(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
+    auto op     = ::STDEXEC::connect(std::move(sender),
+                                 expect_void_receiver(
+                                   ::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
     ::STDEXEC::start(op);
     CHECK(ctx.run() != 0);
     CHECK(ctx.stopped());
@@ -829,27 +916,32 @@ namespace {
     CHECK(!cancelled);
   }
 
-  TEST_CASE("Upon abandonment the stop token is no longer in use", "[asioexec][use_sender]") {
-    bool cancelled = false;
+  TEST_CASE("Upon abandonment the stop token is no longer in use", "[asioexec][use_sender]")
+  {
+    bool                           cancelled = false;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h)
-            .assign([&](auto&&...) noexcept { cancelled = true; });
-          const auto ex = asio_impl::get_associated_executor(h, ctx.get_executor());
-          asio_impl::post(ex, [h = std::move(h)]() mutable {
-            auto local = std::move(h);
-            (void) local;
-          });
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept
+                                                                { cancelled = true; });
+          auto const ex = asio_impl::get_associated_executor(h, ctx.get_executor());
+          asio_impl::post(ex,
+                          [h = std::move(h)]() mutable
+                          {
+                            auto local = std::move(h);
+                            (void) local;
+                          });
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto op = ::STDEXEC::connect(
-      std::move(sender),
-      expect_stopped_receiver(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
+    auto op     = ::STDEXEC::connect(std::move(sender),
+                                 expect_stopped_receiver(
+                                   ::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
     ::STDEXEC::start(op);
     CHECK(ctx.run() != 0);
     CHECK(ctx.stopped());
@@ -858,24 +950,26 @@ namespace {
     CHECK(!cancelled);
   }
 
-  TEST_CASE(
-    "Upon abandonment within the initiating function the stop token is no longer in use",
-    "[asioexec][use_sender]") {
-    bool cancelled = false;
+  TEST_CASE("Upon abandonment within the initiating function the stop token is no longer in use",
+            "[asioexec][use_sender]")
+  {
+    bool                           cancelled = false;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h)
-            .assign([&](auto&&...) noexcept { cancelled = true; });
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept
+                                                                { cancelled = true; });
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto op = ::STDEXEC::connect(
-      std::move(sender),
-      expect_stopped_receiver(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
+    auto op     = ::STDEXEC::connect(std::move(sender),
+                                 expect_stopped_receiver(
+                                   ::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}));
     ::STDEXEC::start(op);
     CHECK(ctx.run() == 0);
     CHECK(ctx.stopped());
@@ -884,23 +978,26 @@ namespace {
     CHECK(!cancelled);
   }
 
-  TEST_CASE("Upon exception the stop token is no longer in use", "[asioexec][use_sender]") {
-    bool cancelled = false;
-    std::exception_ptr ex;
+  TEST_CASE("Upon exception the stop token is no longer in use", "[asioexec][use_sender]")
+  {
+    bool                           cancelled = false;
+    std::exception_ptr             ex;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h)
-            .assign([&](auto&&...) noexcept { cancelled = true; });
-          const auto ex = asio_impl::get_associated_executor(h, ctx.get_executor());
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept
+                                                                { cancelled = true; });
+          auto const ex = asio_impl::get_associated_executor(h, ctx.get_executor());
           asio_impl::post(ex, [h = std::move(h)]() mutable { throw std::logic_error("Test"); });
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto op = ::STDEXEC::connect(
+    auto op     = ::STDEXEC::connect(
       std::move(sender),
       expect_error_receiver_ex(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}, ex));
     ::STDEXEC::start(op);
@@ -913,24 +1010,26 @@ namespace {
     CHECK(!cancelled);
   }
 
-  TEST_CASE(
-    "Upon exception from the initiating function the stop token is no longer in use",
-    "[asioexec][use_sender]") {
-    bool cancelled = false;
-    std::exception_ptr ex;
+  TEST_CASE("Upon exception from the initiating function the stop token is no longer in use",
+            "[asioexec][use_sender]")
+  {
+    bool                           cancelled = false;
+    std::exception_ptr             ex;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
-          asio_impl::get_associated_cancellation_slot(h)
-            .assign([&](auto&&...) noexcept { cancelled = true; });
+        [&](auto h)
+        {
+          asio_impl::get_associated_cancellation_slot(h).assign([&](auto&&...) noexcept
+                                                                { cancelled = true; });
           throw std::logic_error("Test");
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto op = ::STDEXEC::connect(
+    auto op     = ::STDEXEC::connect(
       std::move(sender),
       expect_error_receiver_ex(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}, ex));
     ::STDEXEC::start(op);
@@ -940,32 +1039,35 @@ namespace {
     CHECK(!cancelled);
   }
 
-  TEST_CASE(
-    "When the initiating function starts an operation and then throws an exception the operation "
-    "which was started may be cancelled, completion is deferred thereuntil, and the thrown "
-    "exception is sent on the error channel",
-    "[asioexec][use_sender]") {
-    std::exception_ptr ex;
+  TEST_CASE("When the initiating function starts an operation and then throws an exception the "
+            "operation "
+            "which was started may be cancelled, completion is deferred thereuntil, and the thrown "
+            "exception is sent on the error channel",
+            "[asioexec][use_sender]")
+  {
+    std::exception_ptr             ex;
     ::STDEXEC::inplace_stop_source source;
-    asio_impl::io_context ctx;
-    asio_impl::system_timer t(ctx);
-    const auto initiating_function = [&]<typename CompletionToken>(CompletionToken&& token) {
+    asio_impl::io_context          ctx;
+    asio_impl::system_timer        t(ctx);
+    auto const initiating_function = [&]<typename CompletionToken>(CompletionToken&& token)
+    {
       return asio_impl::async_initiate<CompletionToken, void()>(
-        [&](auto h) {
+        [&](auto h)
+        {
           t.expires_after(std::chrono::years(1));
-          const auto ex = asio_impl::get_associated_executor(h, t.get_executor());
-          const auto slot = asio_impl::get_associated_cancellation_slot(h);
-          t.async_wait(
-            asio_impl::bind_executor(
-              ex, asio_impl::bind_cancellation_slot(slot, [h = std::move(h)](auto&&...) mutable {
-                std::move(h)();
-              })));
+          auto const ex   = asio_impl::get_associated_executor(h, t.get_executor());
+          auto const slot = asio_impl::get_associated_cancellation_slot(h);
+          t.async_wait(asio_impl::bind_executor(
+            ex,
+            asio_impl::bind_cancellation_slot(slot,
+                                              [h = std::move(h)](auto&&...) mutable
+                                              { std::move(h)(); })));
           throw std::logic_error("Test");
         },
         token);
     };
     auto sender = initiating_function(completion_token);
-    auto ptr = connect_shared(
+    auto ptr    = connect_shared(
       std::move(sender),
       expect_error_receiver_ex(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}, ex));
     start_shared(std::move(ptr));
@@ -978,51 +1080,55 @@ namespace {
     CHECK(ex);
   }
 
-  TEST_CASE(
-    "I/O objects may be transformed to use senders as their default vocabulary with only minimal "
-    "transformations (i.e. no error adaptation)",
-    "[asioexec][completion_token]") {
-    bool invoked = false;
+  TEST_CASE("I/O objects may be transformed to use senders as their default vocabulary with only "
+            "minimal "
+            "transformations (i.e. no error adaptation)",
+            "[asioexec][completion_token]")
+  {
+    bool                  invoked = false;
     asio_impl::io_context ctx;
-    auto t = completion_token.as_default_on(asio_impl::system_timer(ctx));
+    auto                  t = completion_token.as_default_on(asio_impl::system_timer(ctx));
     static_assert(
       std::is_same_v<decltype(t), completion_token_t::as_default_on_t<asio_impl::system_timer>>);
     t.expires_after(std::chrono::milliseconds(5));
-    auto op = ::STDEXEC::connect(
-      t.async_wait() | ::STDEXEC::then([](auto ec) { CHECK(!ec); }),
-      expect_void_receiver_ex(invoked));
+    auto op = ::STDEXEC::connect(t.async_wait() | ::STDEXEC::then([](auto ec) { CHECK(!ec); }),
+                                 expect_void_receiver_ex(invoked));
     ::STDEXEC::start(op);
     CHECK(ctx.run() != 0);
     CHECK(ctx.stopped());
   }
 
-  TEST_CASE(
-    "Substitution into async_result<completion_token, ...>::initiate is SFINAE-friendly",
-    "[asioexec][completion_token]") {
-    asio_impl::io_context ctx;
+  TEST_CASE("Substitution into async_result<completion_token, ...>::initiate is SFINAE-friendly",
+            "[asioexec][completion_token]")
+  {
+    asio_impl::io_context      ctx;
     asio_impl::ip::tcp::socket socket(ctx);
-    asio_impl::streambuf buf;
+    asio_impl::streambuf       buf;
     //  With a SFINAE-unfriendly async_result<...>::initiate the below line doesn't compile because there's a hard compilation error trying to consider the async_read overload for dynamic buffers
     //
     //  See: https://github.com/NVIDIA/stdexec/issues/1684
     auto sender = asio_impl::async_read(socket, buf, completion_token);
-    auto op = ::STDEXEC::connect(
-      std::move(sender) | ::STDEXEC::then([](const auto ec, const auto bytes_transferred) {
-        CHECK(ec);
-        CHECK(!bytes_transferred);
-      }),
-      expect_void_receiver{});
+    auto op     = ::STDEXEC::connect(std::move(sender)
+                                   | ::STDEXEC::then(
+                                     [](auto const ec, auto const bytes_transferred)
+                                     {
+                                       CHECK(ec);
+                                       CHECK(!bytes_transferred);
+                                     }),
+                                 expect_void_receiver{});
     ::STDEXEC::start(op);
     CHECK(ctx.run() != 0);
     CHECK(ctx.stopped());
   }
 
-  TEST_CASE(
-    "Asio operations which declare completion by value but send a mutable lvalue work",
-    "[asioexec][completion_token]") {
-    const auto initiating_function = [](auto&& token) {
+  TEST_CASE("Asio operations which declare completion by value but send a mutable lvalue work",
+            "[asioexec][completion_token]")
+  {
+    auto const initiating_function = [](auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void(int)>(
-        [](auto&& h) {
+        [](auto&& h)
+        {
           int i = 5;
           std::forward<decltype(h)>(h)(i);
         },
@@ -1032,4 +1138,4 @@ namespace {
     ::STDEXEC::start(op);
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/asio/test_use_sender.cpp b/test/exec/asio/test_use_sender.cpp
index 71ead227d..f14c7d572 100644
--- a/test/exec/asio/test_use_sender.cpp
+++ b/test/exec/asio/test_use_sender.cpp
@@ -35,53 +35,50 @@
 using namespace STDEXEC;
 using namespace exec::asio;
 
-namespace {
+namespace
+{
 
   static_assert(
     set_equivalent<
-      detail::use_sender::completion_signatures<completion_signatures<
-        set_value_t(std::error_code),
-        set_stopped_t(),
-        set_error_t(std::exception_ptr)
-      >>,
-      completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>
-    >);
+      detail::use_sender::completion_signatures<
+        completion_signatures<set_value_t(std::error_code),
+                              set_stopped_t(),
+                              set_error_t(std::exception_ptr)>>,
+      completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>>);
   static_assert(
     set_equivalent<
-      detail::use_sender::completion_signatures<completion_signatures<
-        set_value_t(error_code),
-        set_stopped_t(),
-        set_error_t(std::exception_ptr)
-      >>,
-      completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>
-    >);
+      detail::use_sender::completion_signatures<
+        completion_signatures<set_value_t(error_code),
+                              set_stopped_t(),
+                              set_error_t(std::exception_ptr)>>,
+      completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>>);
   static_assert(
     set_equivalent<
-      detail::use_sender::completion_signatures<completion_signatures<
-        set_value_t(error_code, int),
-        set_value_t(int),
-        set_stopped_t(),
-        set_error_t(std::exception_ptr)
-      >>,
-      completion_signatures<set_value_t(int), set_stopped_t(), set_error_t(std::exception_ptr)>
-    >);
+      detail::use_sender::completion_signatures<
+        completion_signatures<set_value_t(error_code, int),
+                              set_value_t(int),
+                              set_stopped_t(),
+                              set_error_t(std::exception_ptr)>>,
+      completion_signatures<set_value_t(int), set_stopped_t(), set_error_t(std::exception_ptr)>>);
 
-  TEST_CASE(
-    "Asio-based asynchronous operation ends with set_stopped when "
-    "cancellation occurs",
-    "[asioexec][use_sender]") {
-    bool stopped = false;
+  TEST_CASE("Asio-based asynchronous operation ends with set_stopped when "
+            "cancellation occurs",
+            "[asioexec][use_sender]")
+  {
+    bool                stopped = false;
     inplace_stop_source source;
 
-    const struct {
-      auto query(const get_stop_token_t&) const noexcept {
+    const struct
+    {
+      auto query(get_stop_token_t const &) const noexcept
+      {
         return source_.get_token();
       }
 
       inplace_stop_source& source_;
     } e{source};
 
-    asio_impl::io_context ctx;
+    asio_impl::io_context   ctx;
     asio_impl::system_timer t(ctx);
     t.expires_after(std::chrono::years(1));
     auto sender = t.async_wait(use_sender);
@@ -90,13 +87,11 @@ namespace {
     static_assert(
       set_equivalent<
         ::STDEXEC::completion_signatures_of_t<decltype(sender), ::STDEXEC::env<>>,
-        completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>
-      >);
+        completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>>);
     static_assert(
       set_equivalent<
         ::STDEXEC::completion_signatures_of_t<const decltype(sender)&, ::STDEXEC::env<>>,
-        completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>
-      >);
+        completion_signatures<set_value_t(), set_stopped_t(), set_error_t(std::exception_ptr)>>);
     CHECK(!ctx.poll());
     CHECK(ctx.stopped());
     ctx.restart();
@@ -112,52 +107,54 @@ namespace {
     CHECK(stopped);
   }
 
-  TEST_CASE(
-    "std::errc::operation_canceled causes the operation to end with "
-    "set_stopped",
-    "[asioexec][use_sender]") {
-    const auto initiating_function = [](auto&& token) {
+  TEST_CASE("std::errc::operation_canceled causes the operation to end with "
+            "set_stopped",
+            "[asioexec][use_sender]")
+  {
+    auto const initiating_function = [](auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void(std::error_code)>(
-        [](auto&& h) {
+        [](auto&& h)
+        {
           std::invoke(std::forward<decltype(h)>(h), make_error_code(std::errc::operation_canceled));
         },
         token);
     };
     bool stopped = false;
-    auto op =
-      ::STDEXEC::connect(initiating_function(use_sender), expect_stopped_receiver_ex(stopped));
+    auto op      = ::STDEXEC::connect(initiating_function(use_sender),
+                                 expect_stopped_receiver_ex(stopped));
     CHECK(!stopped);
     start(op);
     CHECK(stopped);
   }
 
-  TEST_CASE(
-    "errc::operation_canceled (note in the case of Boost.Asio this is "
-    "boost::system::errc::operation_canceled) causes the operation to end with "
-    "set_stopped",
-    "[asioexec][use_sender]") {
-    const auto initiating_function = [](auto&& token) {
+  TEST_CASE("errc::operation_canceled (note in the case of Boost.Asio this is "
+            "boost::system::errc::operation_canceled) causes the operation to end with "
+            "set_stopped",
+            "[asioexec][use_sender]")
+  {
+    auto const initiating_function = [](auto&& token)
+    {
       return asio_impl::async_initiate<decltype(token), void(error_code)>(
-        [](auto&& h) {
-          std::invoke(std::forward<decltype(h)>(h), make_error_code(errc::operation_canceled));
-        },
+        [](auto&& h)
+        { std::invoke(std::forward<decltype(h)>(h), make_error_code(errc::operation_canceled)); },
         token);
     };
     bool stopped = false;
-    auto op =
-      ::STDEXEC::connect(initiating_function(use_sender), expect_stopped_receiver_ex(stopped));
+    auto op      = ::STDEXEC::connect(initiating_function(use_sender),
+                                 expect_stopped_receiver_ex(stopped));
     CHECK(!stopped);
     start(op);
     CHECK(stopped);
   }
 
-  TEST_CASE(
-    "When an Asio-based asynchronous operation which could fail "
-    "completes successfully the success is reported via a value completion "
-    "signal",
-    "[asioexec][use_sender]") {
-    bool invoked = false;
-    asio_impl::io_context ctx;
+  TEST_CASE("When an Asio-based asynchronous operation which could fail "
+            "completes successfully the success is reported via a value completion "
+            "signal",
+            "[asioexec][use_sender]")
+  {
+    bool                    invoked = false;
+    asio_impl::io_context   ctx;
     asio_impl::system_timer t(ctx);
     t.expires_after(std::chrono::milliseconds(1));
     auto sender = t.async_wait(use_sender);
@@ -174,10 +171,11 @@ namespace {
     CHECK(invoked);
   }
 
-  TEST_CASE("Post works with use_sender", "[asioexec][use_sender]") {
-    bool invoked = false;
+  TEST_CASE("Post works with use_sender", "[asioexec][use_sender]")
+  {
+    bool                  invoked = false;
     asio_impl::io_context ctx;
-    auto sender = asio_impl::post(ctx, use_sender);
+    auto                  sender = asio_impl::post(ctx, use_sender);
     CHECK(!ctx.poll());
     CHECK(ctx.stopped());
     ctx.restart();
@@ -193,20 +191,22 @@ namespace {
   }
 
   template <typename CompletionToken>
-  decltype(auto) async_error_code(CompletionToken&& token) {
+  decltype(auto) async_error_code(CompletionToken&& token)
+  {
     using signature_type = void(error_code);
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [](auto&& h) {
-        std::invoke(
-          std::forward<decltype(h)>(h), error_code(make_error_code(std::errc::not_enough_memory)));
+      [](auto&& h)
+      {
+        std::invoke(std::forward<decltype(h)>(h),
+                    error_code(make_error_code(std::errc::not_enough_memory)));
       },
       token);
   }
 
-  TEST_CASE(
-    "Error codes native to the version of Asio used are transformed "
-    "into a system_error",
-    "[asioexec][use_sender]") {
+  TEST_CASE("Error codes native to the version of Asio used are transformed "
+            "into a system_error",
+            "[asioexec][use_sender]")
+  {
     std::exception_ptr ex;
     auto op = ::STDEXEC::connect(async_error_code(use_sender), expect_error_receiver_ex(ex));
     CHECK(!ex);
@@ -216,21 +216,21 @@ namespace {
   }
 
   template <typename CompletionToken>
-  decltype(auto) async_std_error_code(CompletionToken&& token) {
+  decltype(auto) async_std_error_code(CompletionToken&& token)
+  {
     using signature_type = void(std::error_code);
     return asio_impl::async_initiate<CompletionToken, signature_type>(
-      [](auto&& h) {
-        std::invoke(std::forward<decltype(h)>(h), make_error_code(std::errc::not_enough_memory));
-      },
+      [](auto&& h)
+      { std::invoke(std::forward<decltype(h)>(h), make_error_code(std::errc::not_enough_memory)); },
       token);
   }
 
-  TEST_CASE(
-    "Standard error codes are transformed into a std::system_error "
-    "(note that in the case of standalone Asio the error code native to that "
-    "version of Asio a std::error_code are the same and therefore this is a "
-    "duplicate of another test)",
-    "[asioexec][use_sender]") {
+  TEST_CASE("Standard error codes are transformed into a std::system_error "
+            "(note that in the case of standalone Asio the error code native to that "
+            "version of Asio a std::error_code are the same and therefore this is a "
+            "duplicate of another test)",
+            "[asioexec][use_sender]")
+  {
     std::exception_ptr ex;
     auto op = ::STDEXEC::connect(async_std_error_code(use_sender), expect_error_receiver_ex(ex));
     CHECK(!ex);
@@ -239,12 +239,12 @@ namespace {
     CHECK_THROWS_AS(std::rethrow_exception(std::move(ex)), std::system_error);
   }
 
-  TEST_CASE(
-    "I/O objects may be transformed to use senders as their default vocabulary",
-    "[asioexec][use_sender]") {
-    bool invoked = false;
+  TEST_CASE("I/O objects may be transformed to use senders as their default vocabulary",
+            "[asioexec][use_sender]")
+  {
+    bool                  invoked = false;
     asio_impl::io_context ctx;
-    auto t = use_sender.as_default_on(asio_impl::system_timer(ctx));
+    auto                  t = use_sender.as_default_on(asio_impl::system_timer(ctx));
     static_assert(
       std::is_same_v<decltype(t), use_sender_t::as_default_on_t<asio_impl::system_timer>>);
     t.expires_after(std::chrono::milliseconds(5));
@@ -254,20 +254,20 @@ namespace {
     CHECK(ctx.stopped());
   }
 
-  TEST_CASE(
-    "Substitution into async_result<use_sender, ...>::initiate is SFINAE-friendly",
-    "[asioexec][completion_token]") {
-    asio_impl::io_context ctx;
+  TEST_CASE("Substitution into async_result<use_sender, ...>::initiate is SFINAE-friendly",
+            "[asioexec][completion_token]")
+  {
+    asio_impl::io_context      ctx;
     asio_impl::ip::tcp::socket socket(ctx);
-    asio_impl::streambuf buf;
+    asio_impl::streambuf       buf;
     //  With a SFINAE-unfriendly async_result<...>::initiate the below line doesn't compile because there's a hard compilation error trying to consider the async_read overload for dynamic buffers
     //
     //  See: https://github.com/NVIDIA/stdexec/issues/1684
     auto sender = asio_impl::async_read(socket, buf, use_sender);
-    auto op = ::STDEXEC::connect(std::move(sender), expect_error_receiver{});
+    auto op     = ::STDEXEC::connect(std::move(sender), expect_error_receiver{});
     ::STDEXEC::start(op);
     CHECK(ctx.run() != 0);
     CHECK(ctx.stopped());
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_dtor.cpp b/test/exec/async_scope/test_dtor.cpp
index 3b0718ea0..669048be8 100644
--- a/test/exec/async_scope/test_dtor.cpp
+++ b/test/exec/async_scope/test_dtor.cpp
@@ -6,17 +6,20 @@ namespace ex = STDEXEC;
 using exec::async_scope;
 using STDEXEC::sync_wait;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("async_scope can be created and them immediately destructed", "[async_scope][dtor]") {
+  TEST_CASE("async_scope can be created and them immediately destructed", "[async_scope][dtor]")
+  {
     async_scope scope;
     (void) scope;
   }
 
-  TEST_CASE("async_scope destruction after spawning work into it", "[async_scope][dtor]") {
+  TEST_CASE("async_scope destruction after spawning work into it", "[async_scope][dtor]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
-    std::atomic<int> counter{0};
+    ex::scheduler auto       sch = pool.get_scheduler();
+    std::atomic<int>         counter{0};
     {
       async_scope scope;
 
@@ -30,4 +33,4 @@ namespace {
     // We should have all the work executed
     REQUIRE(counter == 10);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_empty.cpp b/test/exec/async_scope/test_empty.cpp
index 623820998..7bf2b815f 100644
--- a/test/exec/async_scope/test_empty.cpp
+++ b/test/exec/async_scope/test_empty.cpp
@@ -7,40 +7,44 @@ namespace ex = STDEXEC;
 using exec::async_scope;
 using STDEXEC::sync_wait;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("empty will complete immediately on an empty async_scope", "[async_scope][empty]") {
+  TEST_CASE("empty will complete immediately on an empty async_scope", "[async_scope][empty]")
+  {
     async_scope scope;
-    bool is_empty{false};
+    bool        is_empty{false};
 
     ex::sender auto snd = scope.on_empty() | ex::then([&] { is_empty = true; });
     sync_wait(std::move(snd));
     REQUIRE(is_empty);
   }
 
-  TEST_CASE("empty sender can properly connect a void receiver", "[async_scope][empty]") {
+  TEST_CASE("empty sender can properly connect a void receiver", "[async_scope][empty]")
+  {
     async_scope scope;
-    bool is_empty{false};
+    bool        is_empty{false};
 
     scope.spawn(ex::just());
 
     ex::sender auto snd = scope.on_empty() | ex::then([&] { is_empty = true; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     REQUIRE(is_empty);
   }
 
-  TEST_CASE("empty will complete after the work is done", "[async_scope][empty]") {
+  TEST_CASE("empty will complete after the work is done", "[async_scope][empty]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // Add some work
     scope.spawn(ex::starts_on(sch, ex::just()));
 
     // The on_empty() sender cannot notify now
-    bool is_empty{false};
+    bool            is_empty{false};
     ex::sender auto snd = ex::starts_on(sch, scope.on_empty()) | ex::then([&] { is_empty = true; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     REQUIRE_FALSE(is_empty);
 
@@ -51,17 +55,18 @@ namespace {
     REQUIRE(is_empty);
   }
 
-  TEST_CASE("TODO: empty can be used multiple times", "[async_scope][empty]") {
+  TEST_CASE("TODO: empty can be used multiple times", "[async_scope][empty]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // Add some work
     scope.spawn(ex::starts_on(sch, ex::just()));
 
     // The on_empty() sender cannot notify now
-    bool is_empty{false};
+    bool            is_empty{false};
     ex::sender auto snd = ex::starts_on(sch, scope.on_empty()) | ex::then([&] { is_empty = true; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     REQUIRE_FALSE(is_empty);
 
@@ -75,7 +80,7 @@ namespace {
     scope.spawn(ex::starts_on(sch, ex::just()));
 
     // The on_empty() sender cannot notify now
-    bool is_empty2{false};
+    bool            is_empty2{false};
     ex::sender auto snd2 = ex::starts_on(sch, scope.on_empty())
                          | ex::then([&] { is_empty2 = true; });
     auto op2 = ex::connect(std::move(snd2), expect_void_receiver{});
@@ -91,16 +96,19 @@ namespace {
 
 // TODO: GCC-11 generates warnings (treated as errors) for the following test
 #if !STDEXEC_GCC() || (STDEXEC_GCC_VERSION >= 12'00)
-  TEST_CASE("waiting on work that spawns more work", "[async_scope][empty]") {
+  TEST_CASE("waiting on work that spawns more work", "[async_scope][empty]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     bool work1_done{false};
-    auto work1 = [&] {
+    auto work1 = [&]
+    {
       work1_done = true;
     };
     bool work2_done{false};
-    auto work2 = [&] {
+    auto work2 = [&]
+    {
       // Spawn work
       scope.spawn(ex::starts_on(sch, ex::just() | ex::then(work1)));
       // We are done
@@ -112,7 +120,7 @@ namespace {
     scope.spawn(ex::starts_on(sch, ex::just() | ex::then(work2)));
 
     // start an on_empty() sender
-    bool is_empty{false};
+    bool            is_empty{false};
     ex::sender auto snd = ex::starts_on(inline_scheduler{}, scope.on_empty())
                         | ex::then([&] { is_empty = true; });
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
@@ -139,13 +147,13 @@ namespace {
 
 // TODO: GCC-11 generates warnings (treated as errors) for the following test
 #if !STDEXEC_GCC() || (STDEXEC_GCC_VERSION >= 12'00)
-  TEST_CASE(
-    "async_scope is empty after adding work when in cancelled state",
-    "[async_scope][empty]") {
+  TEST_CASE("async_scope is empty after adding work when in cancelled state",
+            "[async_scope][empty]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
-    bool is_empty1{false};
+    bool            is_empty1{false};
     ex::sender auto snd = ex::starts_on(inline_scheduler{}, scope.on_empty())
                         | ex::then([&] { is_empty1 = true; });
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
@@ -158,7 +166,7 @@ namespace {
     scope.spawn(ex::starts_on(sch, ex::just()) | ex::upon_stopped([&] { work_executed = true; }));
     // note that we don't tell impulse sender to start the work
 
-    bool is_empty2{false};
+    bool            is_empty2{false};
     ex::sender auto snd2 = ex::starts_on(inline_scheduler{}, scope.on_empty())
                          | ex::then([&] { is_empty2 = true; });
     auto op2 = ex::connect(std::move(snd2), expect_void_receiver{});
@@ -171,4 +179,4 @@ namespace {
     REQUIRE(is_empty2);
   }
 #endif
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_spawn.cpp b/test/exec/async_scope/test_spawn.cpp
index f3208bf9f..3522d0ca0 100644
--- a/test/exec/async_scope/test_spawn.cpp
+++ b/test/exec/async_scope/test_spawn.cpp
@@ -8,32 +8,38 @@ namespace ex = STDEXEC;
 using exec::async_scope;
 using STDEXEC::sync_wait;
 
-namespace {
+namespace
+{
 
   //! Sender that throws exception when connected
-  struct throwing_sender {
-    using sender_concept = STDEXEC::sender_t;
+  struct throwing_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
     template <class Receiver>
-    struct operation {
+    struct operation
+    {
       Receiver rcvr_;
 
-      void start() & noexcept {
+      void start() & noexcept
+      {
         ex::set_value(std::move(rcvr_));
       }
     };
 
     template <class Receiver>
-    auto connect(Receiver&&) && -> operation<std::decay_t<Receiver>> {
+    auto connect(Receiver&&) && -> operation<std::decay_t<Receiver>>
+    {
       STDEXEC_THROW(std::logic_error("cannot connect"));
     }
   };
 
-  TEST_CASE("spawn will execute its work", "[async_scope][spawn]") {
+  TEST_CASE("spawn will execute its work", "[async_scope][spawn]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Non-blocking call
     scope.spawn(ex::starts_on(sch, ex::just() | ex::then([&] { executed = true; })));
@@ -44,8 +50,9 @@ namespace {
     REQUIRE(executed);
   }
 
-  TEST_CASE("spawn will start sender before returning", "[async_scope][spawn]") {
-    bool executed{false};
+  TEST_CASE("spawn will start sender before returning", "[async_scope][spawn]")
+  {
+    bool        executed{false};
     async_scope scope;
 
     // This will be a blocking call
@@ -54,29 +61,32 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE(
-    "spawn will propagate exceptions encountered during op creation",
-    "[async_scope][spawn]") {
+  TEST_CASE("spawn will propagate exceptions encountered during op creation",
+            "[async_scope][spawn]")
+  {
     async_scope scope;
-    STDEXEC_TRY {
+    STDEXEC_TRY
+    {
       scope.spawn(throwing_sender{} | ex::then([&] { FAIL("work should not be executed"); }));
       FAIL("Exceptions should have been thrown");
     }
-    STDEXEC_CATCH(const std::logic_error& e) {
+    STDEXEC_CATCH(std::logic_error const & e)
+    {
       SUCCEED("correct exception caught");
     }
-    STDEXEC_CATCH_ALL {
+    STDEXEC_CATCH_ALL
+    {
       FAIL("invalid exception caught");
     }
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE(
-    "TODO: spawn will keep the scope non-empty until the work is executed",
-    "[async_scope][spawn]") {
+  TEST_CASE("TODO: spawn will keep the scope non-empty until the work is executed",
+            "[async_scope][spawn]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Before adding any operations, the scope is empty
     // TODO: reenable this
@@ -100,12 +110,12 @@ namespace {
     REQUIRE(executed);
   }
 
-  TEST_CASE(
-    "TODO: spawn will keep track on how many operations are in flight",
-    "[async_scope][spawn]") {
+  TEST_CASE("TODO: spawn will keep track on how many operations are in flight",
+            "[async_scope][spawn]")
+  {
     impulse_scheduler sch;
-    std::size_t num_executed{0};
-    async_scope scope;
+    std::size_t       num_executed{0};
+    async_scope       scope;
 
     // Before adding any operations, the scope is empty
     // TODO: reenable this
@@ -113,7 +123,8 @@ namespace {
     // REQUIRE(P2519::__scope::empty(scope));
 
     constexpr std::size_t num_oper = 10;
-    for (std::size_t i = 0; i < num_oper; i++) {
+    for (std::size_t i = 0; i < num_oper; i++)
+    {
       scope.spawn(ex::starts_on(sch, ex::just() | ex::then([&] { num_executed++; })));
       size_t num_expected_ops = i + 1;
       // TODO: reenable this
@@ -122,7 +133,8 @@ namespace {
     }
 
     // Now execute the operations
-    for (std::size_t i = 0; i < num_oper; i++) {
+    for (std::size_t i = 0; i < num_oper; i++)
+    {
       sch.start_next();
       size_t num_expected_ops = num_oper - i - 1;
       // TODO: reenable this
@@ -136,21 +148,30 @@ namespace {
     REQUIRE(num_executed == num_oper);
   }
 
-  TEST_CASE("TODO: spawn work can be cancelled by cancelling the scope", "[async_scope][spawn]") {
+  TEST_CASE("TODO: spawn work can be cancelled by cancelling the scope", "[async_scope][spawn]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     bool cancelled1{false};
     bool cancelled2{false};
 
-    scope.spawn(ex::starts_on(sch, ex::just() | ex::let_stopped([&] {
-                                     cancelled1 = true;
-                                     return ex::just();
-                                   })));
-    scope.spawn(ex::starts_on(sch, ex::just() | ex::let_stopped([&] {
-                                     cancelled2 = true;
-                                     return ex::just();
-                                   })));
+    scope.spawn(ex::starts_on(sch,
+                              ex::just()
+                                | ex::let_stopped(
+                                  [&]
+                                  {
+                                    cancelled1 = true;
+                                    return ex::just();
+                                  })));
+    scope.spawn(ex::starts_on(sch,
+                              ex::just()
+                                | ex::let_stopped(
+                                  [&]
+                                  {
+                                    cancelled2 = true;
+                                    return ex::just();
+                                  })));
 
     // TODO: reenable this
     // REQUIRE(P2519::__scope::op_count(scope) == 2);
@@ -179,32 +200,36 @@ namespace {
   template <typename S>
   concept is_spawn_worthy = requires(async_scope& scope, S&& snd) { scope.spawn(std::move(snd)); };
 
-  TEST_CASE("spawn accepts void senders", "[async_scope][spawn]") {
+  TEST_CASE("spawn accepts void senders", "[async_scope][spawn]")
+  {
     static_assert(is_spawn_worthy<decltype(ex::just())>);
   }
 
-  TEST_CASE("spawn doesn't accept non-void senders", "[async_scope][spawn]") {
+  TEST_CASE("spawn doesn't accept non-void senders", "[async_scope][spawn]")
+  {
     static_assert(!is_spawn_worthy<decltype(ex::just(13))>);
     static_assert(!is_spawn_worthy<decltype(ex::just(3.14))>);
     static_assert(!is_spawn_worthy<decltype(ex::just("hello"))>);
   }
 
-  TEST_CASE("TODO: spawn doesn't accept senders of errors", "[async_scope][spawn]") {
+  TEST_CASE("TODO: spawn doesn't accept senders of errors", "[async_scope][spawn]")
+  {
     // TODO: check if just_error(exception_ptr) should be allowed
     static_assert(is_spawn_worthy<decltype(ex::just_error(std::exception_ptr{}))>);
     static_assert(!is_spawn_worthy<decltype(ex::just_error(std::error_code{}))>);
     static_assert(!is_spawn_worthy<decltype(ex::just_error(-1))>);
   }
 
-  TEST_CASE("spawn should accept senders that send stopped signal", "[async_scope][spawn]") {
+  TEST_CASE("spawn should accept senders that send stopped signal", "[async_scope][spawn]")
+  {
     static_assert(is_spawn_worthy<decltype(ex::just_stopped())>);
   }
 
-  TEST_CASE(
-    "TODO: spawn works with senders that complete with stopped signal",
-    "[async_scope][spawn]") {
+  TEST_CASE("TODO: spawn works with senders that complete with stopped signal",
+            "[async_scope][spawn]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // TODO: reenable this
     // REQUIRE(P2519::__scope::empty(scope));
@@ -223,4 +248,4 @@ namespace {
     // TODO: reenable this
     // REQUIRE(P2519::__scope::empty(scope));
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_spawn_future.cpp b/test/exec/async_scope/test_spawn_future.cpp
index bba0119ff..2f6137700 100644
--- a/test/exec/async_scope/test_spawn_future.cpp
+++ b/test/exec/async_scope/test_spawn_future.cpp
@@ -11,50 +11,56 @@ using ex::sync_wait;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
-namespace {
-  void expect_empty(exec::async_scope& scope) {
-    ex::run_loop loop;
+namespace
+{
+  void expect_empty(exec::async_scope& scope)
+  {
+    ex::run_loop       loop;
     ex::scheduler auto sch = loop.get_scheduler();
     CHECK_FALSE(ex::execute_may_block_caller(sch));
-    auto op = ex::connect(
-      ex::then(
-        scope.on_empty(),
-        [&]() {
-          loop.finish();
+    auto op = ex::connect(ex::then(scope.on_empty(),
+                                   [&]()
+                                   {
+                                     loop.finish();
     }),
-      expect_void_receiver{ex::prop{ex::get_scheduler, sch}});
+                          expect_void_receiver{ex::prop{ex::get_scheduler, sch}});
     ex::start(op);
     loop.run();
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
   //! Sender that throws exception when connected
-  struct throwing_sender {
-    using sender_concept = ex::sender_t;
+  struct throwing_sender
+  {
+    using sender_concept        = ex::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
     template <class Receiver>
-    struct operation {
+    struct operation
+    {
       Receiver rcvr_;
 
-      void start() & noexcept {
+      void start() & noexcept
+      {
         ex::set_value(std::move(rcvr_));
       }
     };
 
     template <class Receiver>
-    auto connect(Receiver&&) && -> operation<std::decay_t<Receiver>> {
+    auto connect(Receiver&&) && -> operation<std::decay_t<Receiver>>
+    {
       throw std::logic_error("cannot connect");
     }
   };
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("spawn_future will execute its work", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future will execute its work", "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Non-blocking call
     {
@@ -70,11 +76,12 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE("spawn_future sender will complete", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future sender will complete", "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed1{false};
-    bool executed2{false};
-    async_scope scope;
+    bool              executed1{false};
+    bool              executed2{false};
+    async_scope       scope;
 
     // Non-blocking call
     ex::sender auto snd = scope.spawn_future(
@@ -91,12 +98,12 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE(
-    "spawn_future sender will complete after the given sender completes",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future sender will complete after the given sender completes",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Non-blocking call
     ex::sender auto snd = scope.spawn_future(
@@ -109,10 +116,11 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE("spawn_future returned sender can be dropped", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future returned sender can be dropped", "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    std::atomic_bool executed{false};
-    async_scope scope;
+    std::atomic_bool  executed{false};
+    async_scope       scope;
 
     // Non-blocking call; simply ignore the returned sender
     (void) scope.spawn_future(ex::starts_on(sch, ex::just() | ex::then([&] { executed = true; })));
@@ -123,12 +131,12 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE(
-    "spawn_future returned sender can be captured and dropped",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future returned sender can be captured and dropped",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Non-blocking call; simply ignore the returned sender
     {
@@ -144,43 +152,48 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("spawn_future with throwing copy", "[async_scope][spawn_future]") {
-    async_scope scope;
+  TEST_CASE("spawn_future with throwing copy", "[async_scope][spawn_future]")
+  {
+    async_scope              scope;
     exec::static_thread_pool pool{2};
 
-    struct throwing_copy {
+    struct throwing_copy
+    {
       throwing_copy() = default;
 
-      throwing_copy(const throwing_copy&) {
+      throwing_copy(throwing_copy const &)
+      {
         throw std::logic_error("cannot copy");
       }
     };
 
     ex::sender auto snd = scope.spawn_future(
-      ex::starts_on(pool.get_scheduler(), exec::just_from([](auto sink) {
-                      return sink(throwing_copy());
-                    })));
-    STDEXEC_TRY {
+      ex::starts_on(pool.get_scheduler(),
+                    exec::just_from([](auto sink) { return sink(throwing_copy()); })));
+    STDEXEC_TRY
+    {
       sync_wait(std::move(snd));
       FAIL("Exceptions should have been thrown");
     }
-    STDEXEC_CATCH(const std::logic_error& e) {
+    STDEXEC_CATCH(std::logic_error const & e)
+    {
       SUCCEED("correct exception caught");
     }
-    STDEXEC_CATCH_ALL {
+    STDEXEC_CATCH_ALL
+    {
       FAIL("invalid exception caught");
     }
     sync_wait(scope.on_empty());
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE(
-    "spawn_future returned sender can be connected but not started",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future returned sender can be connected but not started",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    bool executed2{false};
-    async_scope scope;
+    bool              executed{false};
+    bool              executed2{false};
+    async_scope       scope;
 
     // Non-blocking call; simply ignore the returned sender
     ex::sender auto snd = scope.spawn_future(
@@ -196,8 +209,9 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE("spawn_future will start sender before returning", "[async_scope][spawn_future]") {
-    bool executed{false};
+  TEST_CASE("spawn_future will start sender before returning", "[async_scope][spawn_future]")
+  {
+    bool        executed{false};
     async_scope scope;
 
     // This will be a blocking call
@@ -209,13 +223,13 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE(
-    "spawn_future returned sender can be started after given sender completed",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future returned sender can be started after given sender completed",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    bool executed2{false};
-    async_scope scope;
+    bool              executed{false};
+    bool              executed2{false};
+    async_scope       scope;
 
     ex::sender auto snd = scope.spawn_future(
       ex::starts_on(sch, ex::just() | ex::then([&] { executed = true; })));
@@ -231,32 +245,35 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE(
-    "spawn_future will propagate exceptions encountered during op creation",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future will propagate exceptions encountered during op creation",
+            "[async_scope][spawn_future]")
+  {
     async_scope scope;
-    STDEXEC_TRY {
+    STDEXEC_TRY
+    {
       ex::sender auto snd = scope.spawn_future(
         throwing_sender{} | ex::then([&] { FAIL("work should not be executed"); }));
       (void) snd;
       FAIL("Exceptions should have been thrown");
     }
-    STDEXEC_CATCH(const std::logic_error& e) {
+    STDEXEC_CATCH(std::logic_error const & e)
+    {
       SUCCEED("correct exception caught");
     }
-    STDEXEC_CATCH_ALL {
+    STDEXEC_CATCH_ALL
+    {
       FAIL("invalid exception caught");
     }
     expect_empty(scope);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE(
-    "TODO: spawn_future will keep the scope non-empty until the work is executed",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future will keep the scope non-empty until the work is executed",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    bool executed{false};
-    async_scope scope;
+    bool              executed{false};
+    async_scope       scope;
 
     // Before adding any operations, the scope is empty
     // TODO: reenable this
@@ -284,9 +301,9 @@ namespace {
     REQUIRE(executed);
   }
 
-  TEST_CASE(
-    "TODO: spawn_future will keep track on how many operations are in flight",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future will keep track on how many operations are in flight",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
     // std::size_t num_executed{0};
     async_scope scope;
@@ -320,26 +337,32 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE(
-    "TODO: spawn_future work can be cancelled by cancelling the scope",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future work can be cancelled by cancelling the scope",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     bool cancelled1{false};
     bool cancelled2{false};
 
     {
-      ex::sender auto snd1 = scope
-                               .spawn_future(ex::starts_on(sch, ex::just() | ex::let_stopped([&] {
-                                                                  cancelled1 = true;
-                                                                  return ex::just();
-                                                                })));
-      ex::sender auto snd2 = scope
-                               .spawn_future(ex::starts_on(sch, ex::just() | ex::let_stopped([&] {
-                                                                  cancelled2 = true;
-                                                                  return ex::just();
-                                                                })));
+      ex::sender auto snd1 = scope.spawn_future(ex::starts_on(sch,
+                                                              ex::just()
+                                                                | ex::let_stopped(
+                                                                  [&]
+                                                                  {
+                                                                    cancelled1 = true;
+                                                                    return ex::just();
+                                                                  })));
+      ex::sender auto snd2 = scope.spawn_future(ex::starts_on(sch,
+                                                              ex::just()
+                                                                | ex::let_stopped(
+                                                                  [&]
+                                                                  {
+                                                                    cancelled2 = true;
+                                                                    return ex::just();
+                                                                  })));
       (void) snd1;
       (void) snd2;
     }
@@ -374,33 +397,36 @@ namespace {
     scope.spawn_future(std::move(snd));
   };
 
-  TEST_CASE("spawn_future accepts void senders", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future accepts void senders", "[async_scope][spawn_future]")
+  {
     static_assert(is_spawn_future_worthy<decltype(ex::just())>);
   }
 
-  TEST_CASE("spawn_future accepts non-void senders", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future accepts non-void senders", "[async_scope][spawn_future]")
+  {
     static_assert(is_spawn_future_worthy<decltype(ex::just(13))>);
     static_assert(is_spawn_future_worthy<decltype(ex::just(3.14))>);
     static_assert(is_spawn_future_worthy<decltype(ex::just("hello"))>);
   }
 
-  TEST_CASE("spawn_future accepts senders of errors", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future accepts senders of errors", "[async_scope][spawn_future]")
+  {
     static_assert(is_spawn_future_worthy<decltype(ex::just_error(std::exception_ptr{}))>);
     static_assert(is_spawn_future_worthy<decltype(ex::just_error(std::error_code{}))>);
     static_assert(is_spawn_future_worthy<decltype(ex::just_error(-1))>);
   }
 
-  TEST_CASE(
-    "spawn_future should accept senders that send stopped signal",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future should accept senders that send stopped signal",
+            "[async_scope][spawn_future]")
+  {
     static_assert(is_spawn_future_worthy<decltype(ex::just_stopped())>);
   }
 
-  TEST_CASE(
-    "TODO: spawn_future works with senders that complete with stopped signal",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future works with senders that complete with stopped signal",
+            "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // TODO: reenable this
     // REQUIRE(P2519::__scope::empty(scope));
@@ -422,9 +448,10 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE("spawn_future forwards value to returned sender", "[async_scope][spawn_future]") {
+  TEST_CASE("spawn_future forwards value to returned sender", "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // TODO: reenable this
     // REQUIRE(P2519::__scope::empty(scope));
@@ -435,9 +462,10 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE("TODO: spawn_future forwards error to returned sender", "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future forwards error to returned sender", "[async_scope][spawn_future]")
+  {
     impulse_scheduler sch;
-    async_scope scope;
+    async_scope       scope;
 
     // TODO: reenable this
     // REQUIRE(P2519::__scope::empty(scope));
@@ -457,9 +485,9 @@ namespace {
     expect_empty(scope);
   }
 
-  TEST_CASE(
-    "TODO: spawn_future forwards stopped signal to returned sender",
-    "[async_scope][spawn_future]") {
+  TEST_CASE("TODO: spawn_future forwards stopped signal to returned sender",
+            "[async_scope][spawn_future]")
+  {
     // impulse_scheduler sch;
     async_scope scope;
 
@@ -473,4 +501,4 @@ namespace {
     // ex::start(op);
     expect_empty(scope);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_start_now.cpp b/test/exec/async_scope/test_start_now.cpp
index e802d1418..99d545d6f 100644
--- a/test/exec/async_scope/test_start_now.cpp
+++ b/test/exec/async_scope/test_start_now.cpp
@@ -12,10 +12,12 @@ using exec::async_scope;
 using exec::start_now;
 using STDEXEC::sync_wait;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("start_now one", "[async_scope][start_now]") {
-    bool executed{false};
+  TEST_CASE("start_now one", "[async_scope][start_now]")
+  {
+    bool        executed{false};
     async_scope scope;
 
     // This will be a blocking call
@@ -24,51 +26,53 @@ namespace {
     REQUIRE(executed);
   }
 
-  TEST_CASE("start_now two", "[async_scope][start_now]") {
-    bool executedA{false};
-    bool executedB{false};
+  TEST_CASE("start_now two", "[async_scope][start_now]")
+  {
+    bool        executedA{false};
+    bool        executedB{false};
     async_scope scope;
 
     // This will be a blocking call
-    auto stg = start_now(
-      scope,
-      ex::just() | ex::then([&]() noexcept { executedA = true; }),
-      ex::just() | ex::then([&]() noexcept { executedB = true; }));
+    auto stg = start_now(scope,
+                         ex::just() | ex::then([&]() noexcept { executedA = true; }),
+                         ex::just() | ex::then([&]() noexcept { executedB = true; }));
     sync_wait(stg.async_wait());
     REQUIRE(executedA);
     REQUIRE(executedB);
   }
 
-  TEST_CASE("start_now two __root_env", "[async_scope][start_now]") {
-    bool executedA{false};
-    bool executedB{false};
+  TEST_CASE("start_now two __root_env", "[async_scope][start_now]")
+  {
+    bool        executedA{false};
+    bool        executedB{false};
     async_scope scope;
 
     // This will be a blocking call
-    auto stg = start_now(
-      STDEXEC::__root_env{},
-      scope,
-      ex::just() | ex::then([&]() noexcept { executedA = true; }),
-      ex::just() | ex::then([&]() noexcept { executedB = true; }));
+    auto stg = start_now(STDEXEC::__root_env{},
+                         scope,
+                         ex::just() | ex::then([&]() noexcept { executedA = true; }),
+                         ex::just() | ex::then([&]() noexcept { executedB = true; }));
     sync_wait(stg.async_wait());
     REQUIRE(executedA);
     REQUIRE(executedB);
   }
 
-  TEST_CASE("start_now two on pool", "[async_scope][start_now]") {
-    bool executedA{false};
-    bool executedB{false};
-    async_scope scope;
+  TEST_CASE("start_now two on pool", "[async_scope][start_now]")
+  {
+    bool                     executedA{false};
+    bool                     executedB{false};
+    async_scope              scope;
     exec::static_thread_pool pool{2};
 
     // This will be a blocking call
-    auto stg = start_now(
-      scope,
-      ex::schedule(pool.get_scheduler()) | ex::then([&]() noexcept { executedA = true; }),
-      ex::schedule(pool.get_scheduler()) | ex::then([&]() noexcept { executedB = true; }));
+    auto stg = start_now(scope,
+                         ex::schedule(pool.get_scheduler())
+                           | ex::then([&]() noexcept { executedA = true; }),
+                         ex::schedule(pool.get_scheduler())
+                           | ex::then([&]() noexcept { executedB = true; }));
     sync_wait(ex::starts_on(pool.get_scheduler(), stg.async_wait()));
     REQUIRE(executedA);
     REQUIRE(executedB);
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/async_scope/test_stop.cpp b/test/exec/async_scope/test_stop.cpp
index 554e0db5c..ba5159cb3 100644
--- a/test/exec/async_scope/test_stop.cpp
+++ b/test/exec/async_scope/test_stop.cpp
@@ -9,31 +9,34 @@ namespace ex = STDEXEC;
 using exec::async_scope;
 using STDEXEC::sync_wait;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("calling request_stop will be visible in stop_source", "[async_scope][stop]") {
+  TEST_CASE("calling request_stop will be visible in stop_source", "[async_scope][stop]")
+  {
     async_scope scope;
 
     scope.request_stop();
     REQUIRE(scope.get_stop_source().stop_requested());
   }
 
-  TEST_CASE("calling request_stop will be visible in stop_token", "[async_scope][stop]") {
+  TEST_CASE("calling request_stop will be visible in stop_token", "[async_scope][stop]")
+  {
     async_scope scope;
 
     scope.request_stop();
     REQUIRE(scope.get_stop_token().stop_requested());
   }
 
-  TEST_CASE(
-    "cancelling the associated stop_source will cancel the async_scope object",
-    "[async_scope][stop]") {
+  TEST_CASE("cancelling the associated stop_source will cancel the async_scope object",
+            "[async_scope][stop]")
+  {
     bool empty = false;
 
     {
       impulse_scheduler sch;
-      async_scope scope;
-      bool called = false;
+      async_scope       scope;
+      bool              called = false;
 
       // put work in the scope
       scope.spawn(ex::starts_on(sch, ex::just()) | ex::upon_stopped([&] { called = true; }));
@@ -41,9 +44,9 @@ namespace {
 
       // start a thread waiting on when the scope is empty:
       exec::single_thread_context thread;
-      auto thread_sch = thread.get_scheduler();
-      exec::start_detached(
-        ex::starts_on(thread_sch, scope.on_empty()) | ex::then([&] { empty = true; }));
+      auto                        thread_sch = thread.get_scheduler();
+      exec::start_detached(ex::starts_on(thread_sch, scope.on_empty())
+                           | ex::then([&] { empty = true; }));
       REQUIRE_FALSE(empty);
 
       // request the scope stop
@@ -54,17 +57,17 @@ namespace {
 
       // Should have completed with a stopped signal
       REQUIRE(called);
-    } // blocks until the separate thread is joined
+    }  // blocks until the separate thread is joined
 
     REQUIRE(empty);
   }
 
-  TEST_CASE(
-    "cancelling the associated stop_source will be visible in stop_token",
-    "[async_scope][stop]") {
+  TEST_CASE("cancelling the associated stop_source will be visible in stop_token",
+            "[async_scope][stop]")
+  {
     async_scope scope;
 
     scope.get_stop_source().request_stop();
     REQUIRE(scope.get_stop_token().stop_requested());
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_any_sequence_of.cpp b/test/exec/sequence/test_any_sequence_of.cpp
index dd543d5f4..f7f539b16 100644
--- a/test/exec/sequence/test_any_sequence_of.cpp
+++ b/test/exec/sequence/test_any_sequence_of.cpp
@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 
-
 #include "exec/sequence/any_sequence_of.hpp"
 #include "exec/sequence/empty_sequence.hpp"
 
@@ -24,127 +23,124 @@
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
-namespace {
+namespace
+{
 
   template <class Receiver>
-  struct ignore_all_item_rcvr {
+  struct ignore_all_item_rcvr
+  {
     using receiver_concept = STDEXEC::receiver_t;
     Receiver rcvr;
 
     [[nodiscard]]
-    auto get_env() const noexcept -> STDEXEC::env_of_t<Receiver> {
+    auto get_env() const noexcept -> STDEXEC::env_of_t<Receiver>
+    {
       return STDEXEC::get_env(rcvr);
     }
 
     template <class... As>
-    void set_value(As&&...) noexcept {
+    void set_value(As&&...) noexcept
+    {
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
 
     template <class E>
-    void set_error(E&&) noexcept {
+    void set_error(E&&) noexcept
+    {
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
   };
 
   template <class Item>
-  struct ignore_all_sender {
-    using sender_concept = STDEXEC::sender_t;
+  struct ignore_all_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
 
     Item item_;
 
-    template <
-      STDEXEC::__decays_to<ignore_all_sender> Self,
-      STDEXEC::receiver_of<completion_signatures> Receiver
-    >
-    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr) noexcept {
-      return STDEXEC::connect(
-        static_cast<Self&&>(self).item_,
-        ignore_all_item_rcvr<Receiver>{static_cast<Receiver&&>(rcvr)});
+    template <STDEXEC::__decays_to<ignore_all_sender>     Self,
+              STDEXEC::receiver_of<completion_signatures> Receiver>
+    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr) noexcept
+    {
+      return STDEXEC::connect(static_cast<Self&&>(self).item_,
+                              ignore_all_item_rcvr<Receiver>{static_cast<Receiver&&>(rcvr)});
     }
     STDEXEC_EXPLICIT_THIS_END(connect)
   };
 
-  struct ignore_all_receiver {
+  struct ignore_all_receiver
+  {
     using receiver_concept = STDEXEC::receiver_t;
 
     template <class Item>
-    auto set_next(Item&& item) noexcept -> ignore_all_sender<STDEXEC::__decay_t<Item>> {
+    auto set_next(Item&& item) noexcept -> ignore_all_sender<STDEXEC::__decay_t<Item>>
+    {
       return {static_cast<Item&&>(item)};
     }
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
-    void set_error(std::exception_ptr) noexcept {
-    }
+    void set_error(std::exception_ptr) noexcept {}
   };
 
-  TEST_CASE(
-    "any_sequence_of - works with empty_sequence",
-    "[sequence_senders][any_sequence_of][empty_sequence]") {
+  TEST_CASE("any_sequence_of - works with empty_sequence",
+            "[sequence_senders][any_sequence_of][empty_sequence]")
+  {
     using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
     STATIC_REQUIRE(
-      std::constructible_from<
-        exec::any_sequence_receiver_ref<Completions>::any_sender<>,
-        decltype(exec::empty_sequence())
-      >);
+      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
+                              decltype(exec::empty_sequence())>);
     exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence =
       exec::empty_sequence();
     auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
-  TEST_CASE("any_sequence_of - works with just(42)", "[sequence_senders][any_sequence_of]") {
+  TEST_CASE("any_sequence_of - works with just(42)", "[sequence_senders][any_sequence_of]")
+  {
     using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
     STATIC_REQUIRE(
-      std::constructible_from<
-        exec::any_sequence_receiver_ref<Completions>::any_sender<>,
-        decltype(STDEXEC::just(42))
-      >);
+      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
+                              decltype(STDEXEC::just(42))>);
     exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just(42);
     auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
-  TEST_CASE("any_sequence_of - works with just()", "[sequence_senders][any_sequence_of]") {
+  TEST_CASE("any_sequence_of - works with just()", "[sequence_senders][any_sequence_of]")
+  {
     using CompletionsFalse = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
-    using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
+    using Completions      = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
     STATIC_REQUIRE_FALSE(
-      std::constructible_from<
-        exec::any_sequence_receiver_ref<CompletionsFalse>::any_sender<>,
-        decltype(STDEXEC::just())
-      >);
+      std::constructible_from<exec::any_sequence_receiver_ref<CompletionsFalse>::any_sender<>,
+                              decltype(STDEXEC::just())>);
     STATIC_REQUIRE(
-      std::constructible_from<
-        exec::any_sequence_receiver_ref<Completions>::any_sender<>,
-        decltype(STDEXEC::just())
-      >);
+      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
+                              decltype(STDEXEC::just())>);
     exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just();
     auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
-  TEST_CASE("any_sequence_of - has an environment", "[sequence_senders][any_sequence_of]") {
+  TEST_CASE("any_sequence_of - has an environment", "[sequence_senders][any_sequence_of]")
+  {
     using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
     exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just();
-    auto env = STDEXEC::get_env(any_sequence);
-    using env_t = decltype(env);
+    auto                                                       env = STDEXEC::get_env(any_sequence);
+    using env_t                                                    = decltype(env);
     STATIC_REQUIRE(
-      std::same_as<
-        env_t,
-        exec::__any::__sender_env<Completions, STDEXEC::__mlist<>, STDEXEC::__mlist<>>
-      >);
+      std::same_as<env_t,
+                   exec::__any::__sender_env<Completions, STDEXEC::__mlist<>, STDEXEC::__mlist<>>>);
   }
 
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/exec/sequence/test_empty_sequence.cpp b/test/exec/sequence/test_empty_sequence.cpp
index a78990d1a..44c14bba1 100644
--- a/test/exec/sequence/test_empty_sequence.cpp
+++ b/test/exec/sequence/test_empty_sequence.cpp
@@ -22,11 +22,12 @@
 using namespace STDEXEC;
 using namespace exec;
 
-namespace {
+namespace
+{
 
-  TEST_CASE(
-    "sequence_senders - empty_sequence is a sequence sender",
-    "[sequence_senders][empty_sequence]") {
+  TEST_CASE("sequence_senders - empty_sequence is a sequence sender",
+            "[sequence_senders][empty_sequence]")
+  {
     using empty_t = decltype(empty_sequence());
     STATIC_REQUIRE(sequence_sender<empty_t, env<>>);
     [[maybe_unused]]
@@ -37,29 +38,31 @@ namespace {
     STATIC_REQUIRE(std::same_as<item_types_of_t<empty_t, env<>>, item_types<>>);
   }
 
-  struct count_set_next_receiver_t {
+  struct count_set_next_receiver_t
+  {
     using receiver_concept = STDEXEC::receiver_t;
     int& count_invocations_;
 
-    auto set_next(auto /* item */) & noexcept {
+    auto set_next(auto /* item */) & noexcept
+    {
       ++count_invocations_;
       return just();
     }
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
   };
 
-  TEST_CASE(
-    "sequence_senders - empty_sequence is a sequence sender to a minimal receiver of set_value_t()",
-    "[sequence_senders][empty_sequence]") {
+  TEST_CASE("sequence_senders - empty_sequence is a sequence sender to a minimal receiver of "
+            "set_value_t()",
+            "[sequence_senders][empty_sequence]")
+  {
     using empty_t = decltype(empty_sequence());
     STATIC_REQUIRE(receiver_of<count_set_next_receiver_t, completion_signatures<set_value_t()>>);
     STATIC_REQUIRE(sequence_sender_to<empty_t, count_set_next_receiver_t>);
 
-    int count{0};
+    int  count{0};
     auto op = subscribe(empty_sequence(), count_set_next_receiver_t{count});
     STDEXEC::start(op);
     CHECK(count == 0);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_ignore_all_values.cpp b/test/exec/sequence/test_ignore_all_values.cpp
index a514030f2..e5241de12 100644
--- a/test/exec/sequence/test_ignore_all_values.cpp
+++ b/test/exec/sequence/test_ignore_all_values.cpp
@@ -20,59 +20,54 @@
 
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("ignore_all_values - ignore empty sequence", "[sequence_senders][ignore_all_values]") {
-    auto sndr = exec::ignore_all_values(exec::empty_sequence());
+  TEST_CASE("ignore_all_values - ignore empty sequence", "[sequence_senders][ignore_all_values]")
+  {
+    auto sndr    = exec::ignore_all_values(exec::empty_sequence());
     using Sender = decltype(sndr);
     STATIC_REQUIRE(STDEXEC::sender_in<Sender, STDEXEC::env<>>);
-    STATIC_REQUIRE(
-      std::same_as<
-        STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
-        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>
-      >);
+    STATIC_REQUIRE(std::same_as<STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
+                                STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>>);
     STATIC_REQUIRE(STDEXEC::sender_expr_for<Sender, exec::ignore_all_values_t>);
     CHECK(STDEXEC::sync_wait(sndr));
   }
 
-  TEST_CASE("ignore_all_values - ignore just(42)", "[sequence_senders][ignore_all_values]") {
-    auto sndr = exec::ignore_all_values(STDEXEC::just(42));
+  TEST_CASE("ignore_all_values - ignore just(42)", "[sequence_senders][ignore_all_values]")
+  {
+    auto sndr    = exec::ignore_all_values(STDEXEC::just(42));
     using Sender = decltype(sndr);
     STATIC_REQUIRE(STDEXEC::sender_in<Sender, STDEXEC::env<>>);
-    STATIC_REQUIRE(
-      std::same_as<
-        STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
-        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>
-      >);
+    STATIC_REQUIRE(std::same_as<STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
+                                STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>>);
     CHECK(STDEXEC::sync_wait(sndr));
   }
 
-  TEST_CASE("ignore_all_values - ignore just()", "[sequence_senders][ignore_all_values]") {
-    auto sndr = exec::ignore_all_values(STDEXEC::just());
+  TEST_CASE("ignore_all_values - ignore just()", "[sequence_senders][ignore_all_values]")
+  {
+    auto sndr    = exec::ignore_all_values(STDEXEC::just());
     using Sender = decltype(sndr);
     STATIC_REQUIRE(STDEXEC::sender_in<Sender, STDEXEC::env<>>);
-    STATIC_REQUIRE(
-      std::same_as<
-        STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
-        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>
-      >);
+    STATIC_REQUIRE(std::same_as<STDEXEC::completion_signatures<STDEXEC::set_value_t()>,
+                                STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>>);
     CHECK(STDEXEC::sync_wait(sndr));
   }
 
-  TEST_CASE("ignore_all_values - ignore just_stopped()", "[sequence_senders][ignore_all_values]") {
-    auto sndr = exec::ignore_all_values(STDEXEC::just_stopped());
+  TEST_CASE("ignore_all_values - ignore just_stopped()", "[sequence_senders][ignore_all_values]")
+  {
+    auto sndr    = exec::ignore_all_values(STDEXEC::just_stopped());
     using Sender = decltype(sndr);
     STATIC_REQUIRE(STDEXEC::sender_in<Sender, STDEXEC::env<>>);
     STATIC_REQUIRE(
-      STDEXEC::__mset_eq<
-        STDEXEC::__mset<STDEXEC::set_value_t(), STDEXEC::set_stopped_t()>,
-        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>
-      >);
+      STDEXEC::__mset_eq<STDEXEC::__mset<STDEXEC::set_value_t(), STDEXEC::set_stopped_t()>,
+                         STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>>);
     CHECK_FALSE(STDEXEC::sync_wait(sndr));
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("ignore_all_values - ignore just_error()", "[sequence_senders][ignore_all_values]") {
+  TEST_CASE("ignore_all_values - ignore just_error()", "[sequence_senders][ignore_all_values]")
+  {
     auto sndr = exec::ignore_all_values(
       STDEXEC::just_error(std::make_exception_ptr(std::runtime_error("test"))));
     using Sender = decltype(sndr);
@@ -80,19 +75,19 @@ namespace {
     STATIC_REQUIRE(
       STDEXEC::__mset_eq<
         STDEXEC::__mset<STDEXEC::set_value_t(), STDEXEC::set_error_t(std::exception_ptr)>,
-        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>
-      >);
+        STDEXEC::completion_signatures_of_t<Sender, STDEXEC::env<>>>);
     CHECK_THROWS(STDEXEC::sync_wait(sndr));
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  struct sequence_op {
-    void start() & noexcept {
-    }
+  struct sequence_op
+  {
+    void start() & noexcept {}
   };
 
   template <class Item>
-  struct sequence {
+  struct sequence
+  {
     using sender_concept = exec::sequence_sender_t;
 
     using completion_signatures =
@@ -101,22 +96,22 @@ namespace {
     using item_types = exec::item_types<Item>;
 
     template <class R>
-    auto subscribe(R&&) const noexcept -> sequence_op {
+    auto subscribe(R&&) const noexcept -> sequence_op
+    {
       return sequence_op{};
     }
   };
 
-  TEST_CASE("ignore_all_values - Merge error and stop signatures from sequence and items") {
-    using just_t = decltype(STDEXEC::just_error(
-      std::make_exception_ptr(std::runtime_error("test"))));
+  TEST_CASE("ignore_all_values - Merge error and stop signatures from sequence and items")
+  {
+    using just_t = decltype(STDEXEC::just_error(std::make_exception_ptr(std::runtime_error("tes"
+                                                                                           "t"))));
     sequence<just_t> seq;
-    auto ignore = exec::ignore_all_values(seq);
-    using ActualSigs = STDEXEC::completion_signatures_of_t<decltype(ignore), STDEXEC::env<>>;
-    using ExpectedSigs = STDEXEC::__mset<
-      STDEXEC::set_value_t(),
-      STDEXEC::set_error_t(int),
-      STDEXEC::set_error_t(std::exception_ptr)
-    >;
+    auto             ignore = exec::ignore_all_values(seq);
+    using ActualSigs        = STDEXEC::completion_signatures_of_t<decltype(ignore), STDEXEC::env<>>;
+    using ExpectedSigs      = STDEXEC::__mset<STDEXEC::set_value_t(),
+                                              STDEXEC::set_error_t(int),
+                                              STDEXEC::set_error_t(std::exception_ptr)>;
     STATIC_REQUIRE(STDEXEC::__mset_eq<ExpectedSigs, ActualSigs>);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_iterate.cpp b/test/exec/sequence/test_iterate.cpp
index c85b693f7..b879df806 100644
--- a/test/exec/sequence/test_iterate.cpp
+++ b/test/exec/sequence/test_iterate.cpp
@@ -24,86 +24,92 @@
 #  include <catch2/catch.hpp>
 #  include <numeric>
 
-namespace {
+namespace
+{
 
   template <class Receiver>
-  struct sum_item_rcvr {
+  struct sum_item_rcvr
+  {
     using receiver_concept = STDEXEC::receiver_t;
     Receiver rcvr;
-    int* sum_;
+    int*     sum_;
 
     [[nodiscard]]
-    auto get_env() const noexcept -> STDEXEC::env_of_t<Receiver> {
+    auto get_env() const noexcept -> STDEXEC::env_of_t<Receiver>
+    {
       return STDEXEC::get_env(rcvr);
     }
 
     template <class... As>
-    void set_value(int x) noexcept {
+    void set_value(int x) noexcept
+    {
       *sum_ += x;
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
 
     template <class E>
-    void set_error(E&&) noexcept {
+    void set_error(E&&) noexcept
+    {
       STDEXEC::set_value(static_cast<Receiver&&>(rcvr));
     }
   };
 
   template <class Item>
-  struct sum_sender {
-    using sender_concept = STDEXEC::sender_t;
+  struct sum_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
 
     Item item_;
     int* sum_;
 
-    template <
-      STDEXEC::__decays_to<sum_sender> Self,
-      STDEXEC::receiver_of<completion_signatures> Receiver
-    >
-    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr) noexcept {
-      return STDEXEC::connect(
-        static_cast<Self&&>(self).item_,
-        sum_item_rcvr<Receiver>{static_cast<Receiver&&>(rcvr), self.sum_});
+    template <STDEXEC::__decays_to<sum_sender>            Self,
+              STDEXEC::receiver_of<completion_signatures> Receiver>
+    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr) noexcept
+    {
+      return STDEXEC::connect(static_cast<Self&&>(self).item_,
+                              sum_item_rcvr<Receiver>{static_cast<Receiver&&>(rcvr), self.sum_});
     }
     STDEXEC_EXPLICIT_THIS_END(connect)
   };
 
   template <class Env = STDEXEC::env<>>
-  struct sum_receiver {
+  struct sum_receiver
+  {
     using receiver_concept = STDEXEC::receiver_t;
 
     int& sum_;
-    Env env_{};
+    Env  env_{};
 
     template <class Item>
-    auto set_next(Item&& item) noexcept -> sum_sender<STDEXEC::__decay_t<Item>> {
+    auto set_next(Item&& item) noexcept -> sum_sender<STDEXEC::__decay_t<Item>>
+    {
       return {static_cast<Item&&>(item), &sum_};
     }
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
-    void set_error(std::exception_ptr) noexcept {
-    }
+    void set_error(std::exception_ptr) noexcept {}
 
     [[nodiscard]]
-    auto get_env() const noexcept -> Env {
+    auto get_env() const noexcept -> Env
+    {
       return env_;
     }
   };
 
-  TEST_CASE("iterate - sum up an array ", "[sequence_senders][iterate]") {
+  TEST_CASE("iterate - sum up an array ", "[sequence_senders][iterate]")
+  {
     std::array<int, 3> array{42, 43, 44};
-    int sum = 0;
-    auto iterate = exec::iterate(std::views::all(array));
+    int                sum     = 0;
+    auto               iterate = exec::iterate(std::views::all(array));
     STATIC_REQUIRE(exec::sequence_sender_in<decltype(iterate), STDEXEC::env<>>);
     STATIC_REQUIRE(STDEXEC::sender_expr_for<decltype(iterate), exec::iterate_t>);
     auto op = exec::subscribe(iterate, sum_receiver<>{.sum_ = sum});
@@ -111,28 +117,31 @@ namespace {
     CHECK(sum == (42 + 43 + 44));
   }
 
-  struct my_domain {
+  struct my_domain
+  {
     template <STDEXEC::sender_expr_for<exec::iterate_t> Sender, class _Env>
-    auto transform_sender(STDEXEC::start_t, Sender&& sender, _Env&&) const noexcept {
+    auto transform_sender(STDEXEC::start_t, Sender&& sender, _Env&&) const noexcept
+    {
       auto range = STDEXEC::__get<1>(std::forward<Sender>(sender));
-      auto sum = std::accumulate(std::ranges::begin(range), std::ranges::end(range), 0);
+      auto sum   = std::accumulate(std::ranges::begin(range), std::ranges::end(range), 0);
       return STDEXEC::just(sum + 1);
     }
   };
 
-  TEST_CASE("iterate - sum up an array with custom domain", "[sequence_senders][iterate]") {
+  TEST_CASE("iterate - sum up an array with custom domain", "[sequence_senders][iterate]")
+  {
     std::array<int, 3> array{42, 43, 44};
-    auto iterate = exec::iterate(std::views::all(array));
+    auto               iterate = exec::iterate(std::views::all(array));
     STATIC_REQUIRE(exec::sequence_sender_in<decltype(iterate), STDEXEC::env<>>);
     STATIC_REQUIRE(STDEXEC::sender_expr_for<decltype(iterate), exec::iterate_t>);
-    auto env = STDEXEC::prop{STDEXEC::get_domain, my_domain{}};
+    auto env  = STDEXEC::prop{STDEXEC::get_domain, my_domain{}};
     using Env = decltype(env);
-    int sum = 0;
-    auto op = exec::subscribe(iterate, sum_receiver<Env>{.sum_ = sum, .env_ = env});
+    int  sum  = 0;
+    auto op   = exec::subscribe(iterate, sum_receiver<Env>{.sum_ = sum, .env_ = env});
     STDEXEC::start(op);
     CHECK(sum == (42 + 43 + 44 + 1));
   }
 
-} // namespace
+}  // namespace
 
-#endif // STDEXEC_HAS_STD_RANGES()
+#endif  // STDEXEC_HAS_STD_RANGES()
diff --git a/test/exec/sequence/test_merge.cpp b/test/exec/sequence/test_merge.cpp
index feb76cc5e..6ac789bda 100644
--- a/test/exec/sequence/test_merge.cpp
+++ b/test/exec/sequence/test_merge.cpp
@@ -39,30 +39,32 @@
 #include <test_common/type_helpers.hpp>
 #include <thread>
 
-namespace {
+namespace
+{
 
-  struct null_receiver {
+  struct null_receiver
+  {
     using receiver_concept = ex::receiver_t;
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
 
     template <class _Error>
-    void set_error(_Error&&) noexcept {
-    }
+    void set_error(_Error&&) noexcept
+    {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
     [[nodiscard]]
-    auto get_env() const noexcept -> ex::env<> {
+    auto get_env() const noexcept -> ex::env<>
+    {
       return {};
     }
 
-    struct ignore_values_fn_t {
+    struct ignore_values_fn_t
+    {
       template <class... _Vs>
-      void operator()(_Vs&&...) const noexcept {
-      }
+      void operator()(_Vs&&...) const noexcept
+      {}
     };
 
     template <ex::sender _Item>
@@ -71,59 +73,67 @@ namespace {
       -> STDEXEC::__call_result_t<
         STDEXEC::upon_error_t,
         STDEXEC::__call_result_t<STDEXEC::then_t, _Item, ignore_values_fn_t>,
-        ignore_values_fn_t
-      > {
-      return STDEXEC::upon_error(
-        STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}), ignore_values_fn_t{});
+        ignore_values_fn_t>
+    {
+      return STDEXEC::upon_error(STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}),
+                                 ignore_values_fn_t{});
     }
   };
 
-  TEST_CASE(
-    "merge - merge two sequence senders of no elements",
-    "[sequence_senders][merge][empty_sequence]") {
-    int counter = 0;
-    auto merged = exec::merge(exec::empty_sequence(), exec::empty_sequence());
-    auto op = exec::subscribe(merged, null_receiver{});
+  TEST_CASE("merge - merge two sequence senders of no elements",
+            "[sequence_senders][merge][empty_sequence]")
+  {
+    int  counter = 0;
+    auto merged  = exec::merge(exec::empty_sequence(), exec::empty_sequence());
+    auto op      = exec::subscribe(merged, null_receiver{});
     ex::start(op);
     CHECK(counter == 0);
   }
 
-  TEST_CASE(
-    "merge - merge three sequence senders of no elements",
-    "[sequence_senders][merge][empty_sequence]") {
-    int counter = 0;
-    auto merged =
-      exec::merge(exec::empty_sequence(), exec::empty_sequence(), exec::empty_sequence());
-    auto op = exec::subscribe(merged, null_receiver{});
+  TEST_CASE("merge - merge three sequence senders of no elements",
+            "[sequence_senders][merge][empty_sequence]")
+  {
+    int  counter = 0;
+    auto merged  = exec::merge(exec::empty_sequence(),
+                              exec::empty_sequence(),
+                              exec::empty_sequence());
+    auto op      = exec::subscribe(merged, null_receiver{});
     ex::start(op);
     CHECK(counter == 0);
   }
 
-  TEST_CASE("merge - merge sender of 2 senders", "[sequence_senders][merge]") {
-    int value = 0;
-    int count = 0;
-    auto merged = exec::merge(ex::just(84), ex::just(-42));
-    auto transformed = exec::transform_each(merged, ex::then([&value, &count](int x) noexcept {
-                                              value += x;
-                                              ++count;
-                                            }));
-    auto op = exec::subscribe(transformed, null_receiver{});
+  TEST_CASE("merge - merge sender of 2 senders", "[sequence_senders][merge]")
+  {
+    int  value       = 0;
+    int  count       = 0;
+    auto merged      = exec::merge(ex::just(84), ex::just(-42));
+    auto transformed = exec::transform_each(merged,
+                                            ex::then(
+                                              [&value, &count](int x) noexcept
+                                              {
+                                                value += x;
+                                                ++count;
+                                              }));
+    auto op          = exec::subscribe(transformed, null_receiver{});
     ex::start(op);
     CHECK(value == 42);
     CHECK(count == 2);
   }
 
-  TEST_CASE(
-    "merge - merge sender of 2 senders and ignores all values",
-    "[sequence_senders][merge][ignore_all_values]") {
-    int value = 0;
-    int count = 0;
-    auto merged = exec::merge(ex::just(84), ex::just(-42));
-    auto transformed = exec::transform_each(merged, ex::then([&value, &count](int x) {
-                                              value += x;
-                                              ++count;
-                                              return value;
-                                            }))
+  TEST_CASE("merge - merge sender of 2 senders and ignores all values",
+            "[sequence_senders][merge][ignore_all_values]")
+  {
+    int  value       = 0;
+    int  count       = 0;
+    auto merged      = exec::merge(ex::just(84), ex::just(-42));
+    auto transformed = exec::transform_each(merged,
+                                            ex::then(
+                                              [&value, &count](int x)
+                                              {
+                                                value += x;
+                                                ++count;
+                                                return value;
+                                              }))
                      | exec::ignore_all_values();
     ex::sync_wait(transformed);
     CHECK(value == 42);
@@ -131,30 +141,35 @@ namespace {
   }
 
 #if STDEXEC_HAS_STD_RANGES()
-  TEST_CASE("merge - merge sender merges all items", "[sequence_senders][merge][iterate]") {
-    auto range = [](auto from, auto to) {
+  TEST_CASE("merge - merge sender merges all items", "[sequence_senders][merge][iterate]")
+  {
+    auto range = [](auto from, auto to)
+    {
       return exec::iterate(std::views::iota(from, to));
     };
-    auto then_each = [](auto f) {
+    auto then_each = [](auto f)
+    {
       return exec::transform_each(ex::then(f));
     };
     // this trampoline is used to interleave the merged iterate() sequences
     // the parameters set the max inline schedule recursion depth and max
     // inline schedule stack size
     exec::trampoline_scheduler sched{16, 512};
-    int total = 0;
-    int count = 0;
-    std::ptrdiff_t max = 0;
-    auto sum = exec::merge(range(100, 120), range(200, 220), range(300, 320))
-             | then_each([&total, &count, &max](int x) noexcept {
-                 std::ptrdiff_t current = 0;
-                 current = std::abs(
-                   reinterpret_cast<char*>(&current) - reinterpret_cast<char*>(&max));
-                 max = current > max ? current : max;
-                 UNSCOPED_INFO("item: " << x << ", stack size: " << current);
-                 total += x;
-                 ++count;
-               });
+    int                        total = 0;
+    int                        count = 0;
+    std::ptrdiff_t             max   = 0;
+    auto                       sum = exec::merge(range(100, 120), range(200, 220), range(300, 320))
+             | then_each(
+                 [&total, &count, &max](int x) noexcept
+                 {
+                   std::ptrdiff_t current = 0;
+                   current                = std::abs(reinterpret_cast<char*>(&current)
+                                      - reinterpret_cast<char*>(&max));
+                   max                    = current > max ? current : max;
+                   UNSCOPED_INFO("item: " << x << ", stack size: " << current);
+                   total += x;
+                   ++count;
+                 });
     // this causes both iterate sequences to use the same trampoline.
     ex::sync_wait(exec::sequence(STDEXEC::schedule(sched), exec::ignore_all_values(sum)));
     UNSCOPED_INFO("max stack size: " << max);
@@ -162,82 +177,92 @@ namespace {
     CHECK(count == 60);
   }
 
-  TEST_CASE(
-    "merge - merge sender merges all items from multiple threads",
-    "[sequence_senders][static_thread_pool][merge][iterate]") {
-
+  TEST_CASE("merge - merge sender merges all items from multiple threads",
+            "[sequence_senders][static_thread_pool][merge][iterate]")
+  {
     exec::single_thread_context ctx0;
-    ex::scheduler auto sched0 = ctx0.get_scheduler();
+    ex::scheduler auto          sched0 = ctx0.get_scheduler();
     exec::single_thread_context ctx1;
-    ex::scheduler auto sched1 = ctx1.get_scheduler();
+    ex::scheduler auto          sched1 = ctx1.get_scheduler();
     exec::single_thread_context ctx2;
-    ex::scheduler auto sched2 = ctx2.get_scheduler();
+    ex::scheduler auto          sched2 = ctx2.get_scheduler();
     exec::single_thread_context ctx3;
-    ex::scheduler auto sched3 = ctx3.get_scheduler();
+    ex::scheduler auto          sched3 = ctx3.get_scheduler();
 
-    auto range = [](auto from, auto to) {
+    auto range = [](auto from, auto to)
+    {
       return exec::iterate(std::views::iota(from, to));
     };
-    auto then_each = [](auto f) {
+    auto then_each = [](auto f)
+    {
       return exec::transform_each(ex::then(f));
     };
-    auto continues_each_on = [](auto sched) {
+    auto continues_each_on = [](auto sched)
+    {
       return exec::transform_each(ex::continues_on(sched));
     };
-    int total = 0;
-    int count = 0;
-    auto sum = exec::merge(
-                 range(100, 120) | continues_each_on(sched0),
-                 range(200, 220) | continues_each_on(sched1),
-                 range(300, 320) | continues_each_on(sched2))
-             | then_each([](int x) noexcept {
-                 // runs on sched0 and sched1 and sched2 in parallel.
-                 // access to shared data would need to be protected
-                 return std::make_tuple(x, std::this_thread::get_id());
-               })
-             | continues_each_on(sched3) | then_each([&total, &count](auto v) {
-                 // runs only on sched3, which is a strand (a static
-                 // pool with one thread)
-                 // it is safe to use shared data here
-                 auto [x, id] = v;
-                 total += x;
-                 ++count;
-                 UNSCOPED_INFO(
-                   "item: " << x << ", from thread id: " << id
-                            << ", on thread id: " << std::this_thread::get_id());
-               });
+    int  total = 0;
+    int  count = 0;
+    auto sum   = exec::merge(range(100, 120) | continues_each_on(sched0),
+                           range(200, 220) | continues_each_on(sched1),
+                           range(300, 320) | continues_each_on(sched2))
+             | then_each(
+                 [](int x) noexcept
+                 {
+                   // runs on sched0 and sched1 and sched2 in parallel.
+                   // access to shared data would need to be protected
+                   return std::make_tuple(x, std::this_thread::get_id());
+                 })
+             | continues_each_on(sched3)
+             | then_each(
+                 [&total, &count](auto v)
+                 {
+                   // runs only on sched3, which is a strand (a static
+                   // pool with one thread)
+                   // it is safe to use shared data here
+                   auto [x, id] = v;
+                   total += x;
+                   ++count;
+                   UNSCOPED_INFO("item: " << x << ", from thread id: " << id
+                                          << ", on thread id: " << std::this_thread::get_id());
+                 });
     ex::sync_wait(exec::sequence(ex::schedule(sched3), exec::ignore_all_values(sum)));
     CHECK(total == 12570);
     CHECK(count == 60);
   }
 #endif
 
-  struct my_domain {
+  struct my_domain
+  {
     template <ex::sender_expr_for<ex::then_t> Sender, class Env>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, const Env&) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender&&, Env const &)
+    {
       return ex::just(int{21});
     }
   };
 
-  TEST_CASE("merge - can be customized late", "[merge][ignore_all_values]") {
+  TEST_CASE("merge - can be customized late", "[merge][ignore_all_values]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<my_domain> sched;
-    int result = 0;
-    int count = 0;
-    auto start = ex::just(std::string{"hello"});
+    int                               result = 0;
+    int                               count  = 0;
+    auto                              start  = ex::just(std::string{"hello"});
     auto with_scheduler = ex::write_env(ex::prop{ex::get_scheduler, inline_scheduler()});
-    auto adaptor = ex::on(sched, ex::then([](std::string x) { return x + ", world"; }))
+    auto adaptor        = ex::on(sched, ex::then([](std::string x) { return x + ", world"; }))
                  | with_scheduler;
-    auto snd =
-      exec::merge(start | exec::transform_each(adaptor), start | exec::transform_each(adaptor))
-      | exec::transform_each(ex::then([&](int x) {
-          result += x;
-          ++count;
-        }))
-      | exec::ignore_all_values();
+    auto snd = exec::merge(start | exec::transform_each(adaptor),
+                           start | exec::transform_each(adaptor))
+             | exec::transform_each(ex::then(
+               [&](int x)
+               {
+                 result += x;
+                 ++count;
+               }))
+             | exec::ignore_all_values();
     ex::sync_wait(snd);
     CHECK(result == 42);
     CHECK(count == 2);
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_merge_each.cpp b/test/exec/sequence/test_merge_each.cpp
index 3cdeb8f3a..709a8372e 100644
--- a/test/exec/sequence/test_merge_each.cpp
+++ b/test/exec/sequence/test_merge_each.cpp
@@ -21,8 +21,8 @@
 #include "exec/sequence/merge.hpp"
 #include "exec/sequence/merge_each.hpp"
 #include "exec/sequence_senders.hpp"
-#include "exec/static_thread_pool.hpp"     // IWYU pragma: keep
-#include "exec/timed_thread_scheduler.hpp" // IWYU pragma: keep for duration_of_t
+#include "exec/static_thread_pool.hpp"      // IWYU pragma: keep
+#include "exec/timed_thread_scheduler.hpp"  // IWYU pragma: keep for duration_of_t
 #include "exec/variant_sender.hpp"
 #include "stdexec/__detail/__meta.hpp"
 #include "stdexec/__detail/__read_env.hpp"
@@ -34,7 +34,8 @@
 
 #include <array>
 
-namespace {
+namespace
+{
   using namespace std::chrono_literals;
   using namespace exec;
   namespace ex = STDEXEC;
@@ -45,78 +46,87 @@ namespace {
                       && ex::__mapply<ex::__msize, _A>::value
                            == ex::__mapply<ex::__msize, _B>::value;
 
-  struct null_receiver {
+  struct null_receiver
+  {
     using receiver_concept = ex::receiver_t;
 
     template <class... _Values>
-    void set_value(_Values&&...) noexcept {
-    }
+    void set_value(_Values&&...) noexcept
+    {}
 
     template <class _Error>
-    void set_error(_Error&&) noexcept {
-    }
+    void set_error(_Error&&) noexcept
+    {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
     [[nodiscard]]
-    auto get_env() const noexcept -> ex::env<> {
+    auto get_env() const noexcept -> ex::env<>
+    {
       return {};
     }
 
-    struct ignore_values_fn_t {
+    struct ignore_values_fn_t
+    {
       template <class... _Vs>
-      void operator()(_Vs&&...) const noexcept {
-      }
+      void operator()(_Vs&&...) const noexcept
+      {}
     };
 
     template <ex::sender _Item>
     [[nodiscard]]
     auto
-      set_next(_Item&& __item) & noexcept(ex::__nothrow_decay_copyable<_Item>) -> next_sender auto {
-      return STDEXEC::upon_error(
-        STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}), ignore_values_fn_t{});
+    set_next(_Item&& __item) & noexcept(ex::__nothrow_decay_copyable<_Item>) -> next_sender auto
+    {
+      return STDEXEC::upon_error(STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}),
+                                 ignore_values_fn_t{});
     }
   };
 
   // a sequence adaptor that applies a function to each item
   [[maybe_unused]]
-  static constexpr auto then_each = [](auto f) {
+  static constexpr auto then_each = [](auto f)
+  {
     return exec::transform_each(ex::then(f));
   };
   // a sequence adaptor that schedules each item to complete
   // on the specified scheduler
   [[maybe_unused]]
-  static constexpr auto continues_each_on = [](auto sched) {
+  static constexpr auto continues_each_on = [](auto sched)
+  {
     return exec::transform_each(ex::continues_on(sched));
   };
   // a sequence adaptor that schedules each item to complete
   // on the specified scheduler after the specified duration
   [[maybe_unused]]
   static constexpr auto delays_each_on =
-    []<class Sched>(Sched sched, duration_of_t<Sched> after) noexcept {
-      auto delay_value = []<class Value>(Value&& value, Sched sched, duration_of_t<Sched> after) {
-        return sequence(schedule_after(sched, after), static_cast<Value&&>(value));
-      };
-      auto delay_adaptor = STDEXEC::__closure<decltype(delay_value), Sched, duration_of_t<Sched>>{
-        {sched, after},
-        {},
-        {}
-      };
-      return exec::transform_each(delay_adaptor);
+    []<class Sched>(Sched sched, duration_of_t<Sched> after) noexcept
+  {
+    auto delay_value = []<class Value>(Value&& value, Sched sched, duration_of_t<Sched> after)
+    {
+      return sequence(schedule_after(sched, after), static_cast<Value&&>(value));
     };
+    auto delay_adaptor = STDEXEC::__closure<decltype(delay_value), Sched, duration_of_t<Sched>>{
+      {sched, after},
+      {},
+      {}
+    };
+    return exec::transform_each(delay_adaptor);
+  };
   // a sequence adaptor that applies a function to each item
   // the function must produce a sequence
   // all the sequences returned from the function are merged
   [[maybe_unused]]
-  static constexpr auto flat_map = [](auto&& f) {
-    auto map_merge = [](auto&& sequence, auto&& f) noexcept {
-      return merge_each(
-        exec::transform_each(
-          static_cast<decltype(sequence)&&>(sequence), ex::then(static_cast<decltype(f)&&>(f))));
+  static constexpr auto flat_map = [](auto&& f)
+  {
+    auto map_merge = [](auto&& sequence, auto&& f) noexcept
+    {
+      return merge_each(exec::transform_each(static_cast<decltype(sequence)&&>(sequence),
+                                             ex::then(static_cast<decltype(f)&&>(f))));
     };
-    return STDEXEC::__closure<decltype(map_merge), decltype(f)>{
-      {static_cast<decltype(f)&&>(f)}, {}, {}};
+    return STDEXEC::__closure<decltype(map_merge), decltype(f)>{{static_cast<decltype(f)&&>(f)},
+                                                                {},
+                                                                {}};
   };
   // when_all requires a successful completion
   // however stop_after_on has no successful completion
@@ -124,85 +134,106 @@ namespace {
   // (the successful completion will never occur)
   [[maybe_unused]]
   static constexpr auto with_void = [](auto&& sender) noexcept
-    -> variant_sender<STDEXEC::__call_result_t<ex::just_t>, decltype(sender)> {
+    -> variant_sender<STDEXEC::__call_result_t<ex::just_t>, decltype(sender)>
+  {
     return {static_cast<decltype(sender)&&>(sender)};
   };
   // with_stop_token_from adds get_stop_token query, that returns the
   // token for the provided stop_source, to the receiver env
   [[maybe_unused]]
-  static constexpr auto with_stop_token_from = [](auto& stop_source) noexcept {
+  static constexpr auto with_stop_token_from = [](auto& stop_source) noexcept
+  {
     return ex::write_env(ex::prop{ex::get_stop_token, stop_source.get_token()});
   };
   // log_start completes with the provided sequence after printing provided string
   [[maybe_unused]]
-  auto log_start = [](auto sequence, auto message) {
-    return exec::sequence(
-      ex::read_env(ex::get_stop_token) | STDEXEC::then([message](auto&& token) noexcept {
-        UNSCOPED_INFO(
-          message << (token.stop_requested() ? ", stop was requested" : ", stop not requested")
-                  << ", on thread id: " << std::this_thread::get_id());
-      }),
-      ex::just(sequence));
+  auto log_start = [](auto sequence, auto message)
+  {
+    return exec::sequence(ex::read_env(ex::get_stop_token)
+                            | STDEXEC::then(
+                              [message](auto&& token) noexcept
+                              {
+                                UNSCOPED_INFO(message
+                                              << (token.stop_requested() ? ", stop was requested"
+                                                                         : ", stop not requested")
+                                              << ", on thread id: " << std::this_thread::get_id());
+                              }),
+                          ex::just(sequence));
   };
   // log_sequence prints the message when each value in the sequence is emitted
   [[maybe_unused]]
-  auto log_sequence = [](auto sequence, auto message) {
-    return sequence | then_each([message](auto&& value) mutable noexcept {
-             UNSCOPED_INFO(message << ", on thread id: " << std::this_thread::get_id());
-             return value;
-           });
+  auto log_sequence = [](auto sequence, auto message)
+  {
+    return sequence
+         | then_each(
+             [message](auto&& value) mutable noexcept
+             {
+               UNSCOPED_INFO(message << ", on thread id: " << std::this_thread::get_id());
+               return value;
+             });
   };
   // emits_stopped completes with set_stopped after printing info
   [[maybe_unused]]
-  auto emits_stopped = []() {
-    return ex::just() | STDEXEC::let_value([]() noexcept {
-             UNSCOPED_INFO("emitting stopped, on thread id: " << std::this_thread::get_id());
-             return ex::just_stopped();
-           });
+  auto emits_stopped = []()
+  {
+    return ex::just()
+         | STDEXEC::let_value(
+             []() noexcept
+             {
+               UNSCOPED_INFO("emitting stopped, on thread id: " << std::this_thread::get_id());
+               return ex::just_stopped();
+             });
   };
   // emits_error completes with set_error(error) after printing info
   [[maybe_unused]]
-  auto emits_error = [](auto error) {
-    return ex::just() | STDEXEC::let_value([error]() noexcept {
-             UNSCOPED_INFO(error.what() << ", on thread id: " << std::this_thread::get_id());
-             return ex::just_error(error);
-           });
+  auto emits_error = [](auto error)
+  {
+    return ex::just()
+         | STDEXEC::let_value(
+             [error]() noexcept
+             {
+               UNSCOPED_INFO(error.what() << ", on thread id: " << std::this_thread::get_id());
+               return ex::just_error(error);
+             });
   };
 
 #if STDEXEC_HAS_STD_RANGES()
 
   // a sequence of numbers from itoa()
   [[maybe_unused]]
-  static constexpr auto range = [](auto from, auto to) {
+  static constexpr auto range = [](auto from, auto to)
+  {
     return exec::iterate(std::views::iota(from, to));
   };
 
   template <ex::sender Sender>
-  struct as_sequence_t : Sender {
+  struct as_sequence_t : Sender
+  {
     using sender_concept = sequence_sender_t;
-    using item_types = exec::item_types<Sender>;
-    auto subscribe(auto receiver) {
+    using item_types     = exec::item_types<Sender>;
+    auto subscribe(auto receiver)
+    {
       return connect(set_next(receiver, *static_cast<Sender*>(this)), receiver);
     }
   };
 
-  TEST_CASE(
-    "merge_each - merge two sequence senders of no elements",
-    "[sequence_senders][merge_each][empty_sequence]") {
+  TEST_CASE("merge_each - merge two sequence senders of no elements",
+            "[sequence_senders][merge_each][empty_sequence]")
+  {
     using empty_sequence_t = STDEXEC::__call_result_t<empty_sequence_t>;
 
     [[maybe_unused]]
     std::array<empty_sequence_t, 2> array{empty_sequence(), empty_sequence()};
 
     [[maybe_unused]]
-    auto sequences = iterate(std::views::all(array));
+    auto sequences    = iterate(std::views::all(array));
     using sequences_t = decltype(sequences);
 
     STATIC_REQUIRE(ex::__ok<item_types_of_t<sequences_t>>);
     STATIC_REQUIRE(ex::__ok<STDEXEC::completion_signatures_of_t<sequences_t>>);
 
     [[maybe_unused]]
-    auto merged = merge_each(sequences);
+    auto merged    = merge_each(sequences);
     using merged_t = decltype(merged);
 
     STATIC_REQUIRE(ex::__ok<item_types_of_t<merged_t>>);
@@ -213,33 +244,35 @@ namespace {
     int count = 0;
 
     auto v = ex::sync_wait(ignore_all_values(
-      merged | then_each([&count](int x) {
-        ++count;
-        UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
-      })));
+      merged
+      | then_each(
+        [&count](int x)
+        {
+          ++count;
+          UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
+        })));
 
     CHECK(count == 0);
     CHECK(v.has_value() == true);
   }
 
-  TEST_CASE(
-    "merge_each - merge two sequence senders of integers",
-    "[sequence_senders][merge_each][empty_sequence]") {
-
+  TEST_CASE("merge_each - merge two sequence senders of integers",
+            "[sequence_senders][merge_each][empty_sequence]")
+  {
     using range_sender_t = STDEXEC::__call_result_t<decltype(range), int, int>;
 
     [[maybe_unused]]
     std::array<range_sender_t, 2> array{range(100, 120), range(200, 220)};
 
     [[maybe_unused]]
-    auto sequences = iterate(std::views::all(array));
+    auto sequences    = iterate(std::views::all(array));
     using sequences_t = decltype(sequences);
 
     STATIC_REQUIRE(ex::__ok<item_types_of_t<sequences_t>>);
     STATIC_REQUIRE(ex::__ok<STDEXEC::completion_signatures_of_t<sequences_t>>);
 
     [[maybe_unused]]
-    auto merged = merge_each(sequences);
+    auto merged    = merge_each(sequences);
     using merged_t = decltype(merged);
 
     STATIC_REQUIRE(ex::__ok<item_types_of_t<merged_t>>);
@@ -250,94 +283,76 @@ namespace {
     int count = 0;
 
     auto v = ex::sync_wait(ignore_all_values(
-      merged | then_each([&count](int x) {
-        ++count;
-        UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
-      })));
+      merged
+      | then_each(
+        [&count](int x)
+        {
+          ++count;
+          UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
+        })));
 
     CHECK(count == 40);
     CHECK(v.has_value() == true);
   }
 
-  TEST_CASE(
-    "merge_each - merge sequence of two sequence senders of integers and one empty sequence",
-    "[sequence_senders][merge_each][merge][empty_sequence]") {
-
+  TEST_CASE("merge_each - merge sequence of two sequence senders of integers and one empty "
+            "sequence",
+            "[sequence_senders][merge_each][merge][empty_sequence]")
+  {
     using range_sequence_t = STDEXEC::__call_result_t<decltype(range), int, int>;
     STATIC_REQUIRE(__well_formed_sequence_sender<range_sequence_t>);
     STATIC_REQUIRE_FALSE(std::same_as<item_types_of_t<range_sequence_t>, item_types<>>);
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<range_sequence_t>,
-        ex::completion_signatures<
-          ex::set_error_t(std::exception_ptr),
-          ex::set_stopped_t(),
-          ex::set_value_t()
-        >
-      >);
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<range_sequence_t>,
+                                ex::completion_signatures<ex::set_error_t(std::exception_ptr),
+                                                          ex::set_stopped_t(),
+                                                          ex::set_value_t()>>);
 
     using just_range_sender_t = ex::__call_result_t<ex::just_t, range_sequence_t>;
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<just_range_sender_t>,
-        ex::completion_signatures<ex::set_value_t(range_sequence_t)>
-      >);
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<just_range_sender_t>,
+                                ex::completion_signatures<ex::set_value_t(range_sequence_t)>>);
 
     using empty_sequence_t = STDEXEC::__call_result_t<empty_sequence_t>;
     STATIC_REQUIRE(__well_formed_sequence_sender<empty_sequence_t>);
     STATIC_REQUIRE(std::same_as<item_types_of_t<empty_sequence_t>, item_types<>>);
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<empty_sequence_t>,
-        ex::completion_signatures<ex::set_value_t()>
-      >);
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<empty_sequence_t>,
+                                ex::completion_signatures<ex::set_value_t()>>);
 
     using just_empty_sender_t = ex::__call_result_t<ex::just_t, empty_sequence_t>;
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<just_empty_sender_t>,
-        ex::completion_signatures<ex::set_value_t(empty_sequence_t)>
-      >);
-
-    auto sequences =
-      merge(ex::just(range(100, 120)), ex::just(empty_sequence()), ex::just(range(200, 220)));
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<just_empty_sender_t>,
+                                ex::completion_signatures<ex::set_value_t(empty_sequence_t)>>);
+
+    auto sequences    = merge(ex::just(range(100, 120)),
+                           ex::just(empty_sequence()),
+                           ex::just(range(200, 220)));
     using sequences_t = decltype(sequences);
 
     STATIC_REQUIRE(ex::__ok<__item_types_of_t<sequences_t>>);
     STATIC_REQUIRE(ex::__ok<ex::completion_signatures_of_t<sequences_t>>);
 
-    STATIC_REQUIRE(
-      __equivalent<
-        __item_types_of_t<sequences_t>,
-        item_types<just_range_sender_t, just_empty_sender_t>
-      >);
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<sequences_t>,
-        ex::completion_signatures<ex::set_stopped_t(), ex::set_value_t()>
-      >);
-
-    auto merged = merge_each(sequences);
+    STATIC_REQUIRE(__equivalent<__item_types_of_t<sequences_t>,
+                                item_types<just_range_sender_t, just_empty_sender_t>>);
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<sequences_t>,
+                                ex::completion_signatures<ex::set_stopped_t(), ex::set_value_t()>>);
+
+    auto merged    = merge_each(sequences);
     using merged_t = decltype(merged);
 
     STATIC_REQUIRE(ex::__ok<__item_types_of_t<merged_t>>);
-    STATIC_REQUIRE(
-      __equivalent<
-        ex::completion_signatures_of_t<merged_t>,
-        ex::completion_signatures<
-          ex::set_error_t(std::exception_ptr),
-          ex::set_stopped_t(),
-          ex::set_value_t()
-        >
-      >);
+    STATIC_REQUIRE(__equivalent<ex::completion_signatures_of_t<merged_t>,
+                                ex::completion_signatures<ex::set_error_t(std::exception_ptr),
+                                                          ex::set_stopped_t(),
+                                                          ex::set_value_t()>>);
 
     int count = 0;
 
     auto v = ex::sync_wait(ignore_all_values(
-      merged | then_each([&count](int x) {
-        ++count;
-        UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
-      })));
+      merged
+      | then_each(
+        [&count](int x)
+        {
+          ++count;
+          UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
+        })));
 
     CHECK(count == 40);
     CHECK(v.has_value() == true);
@@ -368,8 +383,8 @@ namespace {
     CHECK(count == 20);
     CHECK(v.has_value() == false);
   }
-#  endif // 0
+#  endif  // 0
 
-#endif // STDEXEC_HAS_STD_RANGES()
+#endif  // STDEXEC_HAS_STD_RANGES()
 
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_merge_each_threaded.cpp b/test/exec/sequence/test_merge_each_threaded.cpp
index 17f86cae1..75e42919d 100644
--- a/test/exec/sequence/test_merge_each_threaded.cpp
+++ b/test/exec/sequence/test_merge_each_threaded.cpp
@@ -36,7 +36,8 @@
 #include <iomanip>
 #include <stdexcept>
 
-namespace {
+namespace
+{
   using namespace std::chrono_literals;
   using namespace exec;
   namespace ex = STDEXEC;
@@ -47,58 +48,65 @@ namespace {
                       && ex::__mapply<ex::__msize, _A>::value
                            == ex::__mapply<ex::__msize, _B>::value;
 
-  struct null_receiver {
+  struct null_receiver
+  {
     using receiver_concept = ex::receiver_t;
 
     template <class... _Values>
-    void set_value(_Values&&...) noexcept {
-    }
+    void set_value(_Values&&...) noexcept
+    {}
 
     template <class _Error>
-    void set_error(_Error&&) noexcept {
-    }
+    void set_error(_Error&&) noexcept
+    {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
     [[nodiscard]]
-    auto get_env() const noexcept -> ex::env<> {
+    auto get_env() const noexcept -> ex::env<>
+    {
       return {};
     }
 
-    struct ignore_values_fn_t {
+    struct ignore_values_fn_t
+    {
       template <class... _Vs>
-      void operator()(_Vs&&...) const noexcept {
-      }
+      void operator()(_Vs&&...) const noexcept
+      {}
     };
 
     template <ex::sender _Item>
     [[nodiscard]]
     auto
-      set_next(_Item&& __item) & noexcept(ex::__nothrow_decay_copyable<_Item>) -> next_sender auto {
-      return STDEXEC::upon_error(
-        STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}), ignore_values_fn_t{});
+    set_next(_Item&& __item) & noexcept(ex::__nothrow_decay_copyable<_Item>) -> next_sender auto
+    {
+      return STDEXEC::upon_error(STDEXEC::then(static_cast<_Item&&>(__item), ignore_values_fn_t{}),
+                                 ignore_values_fn_t{});
     }
   };
 
   // a sequence adaptor that applies a function to each item
   [[maybe_unused]]
-  static constexpr auto then_each = [](auto f) {
+  static constexpr auto then_each = [](auto f)
+  {
     return exec::transform_each(ex::then(f));
   };
 
   // a sequence adaptor that schedules each item to complete
   // on the specified scheduler
   [[maybe_unused]]
-  static constexpr auto continues_each_on = [](auto sched) {
+  static constexpr auto continues_each_on = [](auto sched)
+  {
     return exec::transform_each(ex::continues_on(sched));
   };
 
   // a sequence adaptor that schedules each item to complete
   // on the specified scheduler after the specified duration
   [[maybe_unused]]
-  static constexpr auto delays_each_on = []<class Sched>(Sched sched, auto after) noexcept {
-    auto delay_value = []<class Value>(Value&& value, Sched sched, auto after) {
+  static constexpr auto delays_each_on = []<class Sched>(Sched sched, auto after) noexcept
+  {
+    auto delay_value = []<class Value>(Value&& value, Sched sched, auto after)
+    {
       return sequence(schedule_after(sched, after), static_cast<Value&&>(value));
     };
     auto delay_adaptor = STDEXEC::__closure(delay_value, sched, after);
@@ -109,11 +117,12 @@ namespace {
   // the function must produce a sequence
   // all the sequences returned from the function are merged
   [[maybe_unused]]
-  static constexpr auto flat_map = [](auto&& f) {
-    auto map_merge = [](auto&& sequence, auto&& f) noexcept {
-      return merge_each(
-        exec::transform_each(
-          static_cast<decltype(sequence)&&>(sequence), ex::then(static_cast<decltype(f)&&>(f))));
+  static constexpr auto flat_map = [](auto&& f)
+  {
+    auto map_merge = [](auto&& sequence, auto&& f) noexcept
+    {
+      return merge_each(exec::transform_each(static_cast<decltype(sequence)&&>(sequence),
+                                             ex::then(static_cast<decltype(f)&&>(f))));
     };
     return STDEXEC::__closure(map_merge, static_cast<decltype(f)&&>(f));
   };
@@ -124,247 +133,282 @@ namespace {
   // (the successful completion will never occur)
   [[maybe_unused]]
   static constexpr auto with_void = [](auto&& sender) noexcept
-    -> variant_sender<STDEXEC::__call_result_t<ex::just_t>, STDEXEC::__decay_t<decltype(sender)>> {
+    -> variant_sender<STDEXEC::__call_result_t<ex::just_t>, STDEXEC::__decay_t<decltype(sender)>>
+  {
     return {static_cast<decltype(sender)&&>(sender)};
   };
 
   // with_stop_token_from adds get_stop_token query, that returns the
   // token for the provided stop_source, to the receiver env
   [[maybe_unused]]
-  static constexpr auto with_stop_token_from = [](auto& stop_source) noexcept {
+  static constexpr auto with_stop_token_from = [](auto& stop_source) noexcept
+  {
     return ex::write_env(ex::prop{ex::get_stop_token, stop_source.get_token()});
   };
 
   // log_start completes with the provided sequence after printing provided string
   [[maybe_unused]]
-  auto log_start = [](auto sequence, auto message) {
-    return exec::sequence(
-      ex::read_env(ex::get_stop_token) | STDEXEC::then([message](auto&& token) noexcept {
-        UNSCOPED_INFO(
-          message << (token.stop_requested() ? ", stop was requested" : ", stop not requested")
-                  << ", on thread id: " << std::this_thread::get_id());
-      }),
-      ex::just(sequence));
+  auto log_start = [](auto sequence, auto message)
+  {
+    return exec::sequence(ex::read_env(ex::get_stop_token)
+                            | STDEXEC::then(
+                              [message](auto&& token) noexcept
+                              {
+                                UNSCOPED_INFO(message
+                                              << (token.stop_requested() ? ", stop was requested"
+                                                                         : ", stop not requested")
+                                              << ", on thread id: " << std::this_thread::get_id());
+                              }),
+                          ex::just(sequence));
   };
 
   // log_sequence prints the message when each value in the sequence is emitted
   [[maybe_unused]]
-  auto log_sequence = [](auto sequence, auto message) {
-    return sequence | then_each([message](auto&& value) mutable noexcept {
-             UNSCOPED_INFO(message << ", on thread id: " << std::this_thread::get_id());
-             return value;
-           });
+  auto log_sequence = [](auto sequence, auto message)
+  {
+    return sequence
+         | then_each(
+             [message](auto&& value) mutable noexcept
+             {
+               UNSCOPED_INFO(message << ", on thread id: " << std::this_thread::get_id());
+               return value;
+             });
   };
 
   // emits_stopped completes with set_stopped after printing info
   [[maybe_unused]]
-  auto emits_stopped = []() {
-    return ex::just() | STDEXEC::let_value([]() noexcept {
-             UNSCOPED_INFO("emitting stopped, on thread id: " << std::this_thread::get_id());
-             return ex::just_stopped();
-           });
+  auto emits_stopped = []()
+  {
+    return ex::just()
+         | STDEXEC::let_value(
+             []() noexcept
+             {
+               UNSCOPED_INFO("emitting stopped, on thread id: " << std::this_thread::get_id());
+               return ex::just_stopped();
+             });
   };
 
   // emits_error completes with set_error(error) after printing info
   [[maybe_unused]]
-  auto emits_error = [](auto error) {
-    return ex::just() | STDEXEC::let_value([error]() noexcept {
-             UNSCOPED_INFO(error.what() << ", on thread id: " << std::this_thread::get_id());
-             return ex::just_error(error);
-           });
+  auto emits_error = [](auto error)
+  {
+    return ex::just()
+         | STDEXEC::let_value(
+             [error]() noexcept
+             {
+               UNSCOPED_INFO(error.what() << ", on thread id: " << std::this_thread::get_id());
+               return ex::just_error(error);
+             });
   };
 
 #if STDEXEC_HAS_STD_RANGES()
 
   // a sequence of numbers from itoa()
   [[maybe_unused]]
-  static constexpr auto range = [](auto from, auto to) {
+  static constexpr auto range = [](auto from, auto to)
+  {
     return exec::iterate(std::views::iota(from, to));
   };
 
   template <ex::sender Sender>
-  struct as_sequence_t : Sender {
+  struct as_sequence_t : Sender
+  {
     using sender_concept = sequence_sender_t;
-    using item_types = exec::item_types<Sender>;
+    using item_types     = exec::item_types<Sender>;
     template <ex::receiver Receiver>
-    auto subscribe(Receiver receiver) {
+    auto subscribe(Receiver receiver)
+    {
       return connect(set_next(receiver, *static_cast<Sender*>(this)), receiver);
     }
   };
 
-  TEST_CASE(
-    "merge_each - merge_each sender merges all items from multiple threads",
-    "[sequence_senders][single_thread_context][merge_each][merge][iterate]") {
-
+  TEST_CASE("merge_each - merge_each sender merges all items from multiple threads",
+            "[sequence_senders][single_thread_context][merge_each][merge][iterate]")
+  {
     exec::single_thread_context ctx0;
-    ex::scheduler auto sched0 = ctx0.get_scheduler();
+    ex::scheduler auto          sched0 = ctx0.get_scheduler();
     exec::single_thread_context ctx1;
-    ex::scheduler auto sched1 = ctx1.get_scheduler();
+    ex::scheduler auto          sched1 = ctx1.get_scheduler();
     exec::single_thread_context ctx2;
-    ex::scheduler auto sched2 = ctx2.get_scheduler();
+    ex::scheduler auto          sched2 = ctx2.get_scheduler();
 
-    auto sequences = merge(
-      ex::just(range(100, 120) | continues_each_on(sched1)),
-      ex::just(empty_sequence()),
-      ex::just(range(200, 220) | continues_each_on(sched2)));
+    auto sequences = merge(ex::just(range(100, 120) | continues_each_on(sched1)),
+                           ex::just(empty_sequence()),
+                           ex::just(range(200, 220) | continues_each_on(sched2)));
 
     auto merged = merge_each(sequences);
 
     int count = 0;
 
     auto v = ex::sync_wait(ignore_all_values(
-      merged | continues_each_on(sched0) | then_each([&count](int x) {
-        ++count;
-        UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
-      })));
+      merged | continues_each_on(sched0)
+      | then_each(
+        [&count](int x)
+        {
+          ++count;
+          UNSCOPED_INFO("item: " << x << ", on thread id: " << std::this_thread::get_id());
+        })));
 
     CHECK(count == 40);
     CHECK(v.has_value() == true);
   }
 
-  TEST_CASE(
-    "merge_each - merge_each sender stops on failed item while merging all items from multiple "
-    "threads",
-    "[sequence_senders][single_thread_context][merge_each][merge][iterate]") {
-
+  TEST_CASE("merge_each - merge_each sender stops on failed item while merging all items from "
+            "multiple "
+            "threads",
+            "[sequence_senders][single_thread_context][merge_each][merge][iterate]")
+  {
     exec::single_thread_context ctx0;
-    ex::scheduler auto sched0 = ctx0.get_scheduler();
-    exec::timed_thread_context ctx1;
-    ex::scheduler auto sched1 = ctx1.get_scheduler();
-    auto origin = now(sched1);
+    ex::scheduler auto          sched0 = ctx0.get_scheduler();
+    exec::timed_thread_context  ctx1;
+    ex::scheduler auto          sched1 = ctx1.get_scheduler();
+    auto                        origin = now(sched1);
 
-    auto elapsed_ms = [&sched1, origin]() {
+    auto elapsed_ms = [&sched1, origin]()
+    {
       using namespace std::chrono;
       return duration_cast<milliseconds>(now(sched1) - origin).count();
     };
 
-    auto stop_after_on = [sched0, elapsed_ms](auto sched, auto after) {
+    auto stop_after_on = [sched0, elapsed_ms](auto sched, auto after)
+    {
       return schedule_after(sched, after)
-           | STDEXEC::continues_on(sched0) // serializes output on the sched0 strand
-           | STDEXEC::let_value([elapsed_ms]() noexcept {
-               UNSCOPED_INFO(
-                 "requesting stop  - at: " << std::setw(3) << elapsed_ms()
-                                           << "ms, on thread id: " << std::this_thread::get_id());
-               return ex::just_stopped();
-             });
+           | STDEXEC::continues_on(sched0)  // serializes output on the sched0 strand
+           | STDEXEC::let_value(
+               [elapsed_ms]() noexcept
+               {
+                 UNSCOPED_INFO("requesting stop  - at: " << std::setw(3) << elapsed_ms()
+                                                         << "ms, on thread id: "
+                                                         << std::this_thread::get_id());
+                 return ex::just_stopped();
+               });
     };
 
-    auto error_after_on = [sched0, elapsed_ms](auto sched, auto after, auto error) {
+    auto error_after_on = [sched0, elapsed_ms](auto sched, auto after, auto error)
+    {
       return schedule_after(sched, after)
-           | STDEXEC::continues_on(sched0) // serializes output on the sched0 strand
-           | STDEXEC::let_value([elapsed_ms, error]() noexcept {
-               UNSCOPED_INFO(
-                 error.what() << " - at: " << std::setw(3) << elapsed_ms()
-                              << "ms, on thread id: " << std::this_thread::get_id());
-               return ex::just_error(error);
-             });
+           | STDEXEC::continues_on(sched0)  // serializes output on the sched0 strand
+           | STDEXEC::let_value(
+               [elapsed_ms, error]() noexcept
+               {
+                 UNSCOPED_INFO(error.what() << " - at: " << std::setw(3) << elapsed_ms()
+                                            << "ms, on thread id: " << std::this_thread::get_id());
+                 return ex::just_error(error);
+               });
     };
 
     // a sequence whose items are sequences
     auto sequences = merge(
-      ex::just(stop_after_on(sched1, 10ms)),                                         // no items
-      ex::just(range(100, 120)),                                                     // int items
-      ex::just(empty_sequence()),                                                    // no items
-      ex::just(range(200, 220)),                                                     // int items
-      ex::just(error_after_on(sched1, 40ms, std::runtime_error{"failed sequence "})) // no items
+      ex::just(stop_after_on(sched1, 10ms)),                                          // no items
+      ex::just(range(100, 120)),                                                      // int items
+      ex::just(empty_sequence()),                                                     // no items
+      ex::just(range(200, 220)),                                                      // int items
+      ex::just(error_after_on(sched1, 40ms, std::runtime_error{"failed sequence "}))  // no items
     );
 
     // apply delays_each_on to every sequence item and
     // merge all the new sequences
-    auto merged = sequences | flat_map([sched1](auto sequence) {
-                    return sequence | delays_each_on(sched1, 10ms);
-                  });
+    auto merged = sequences
+                | flat_map([sched1](auto sequence)
+                           { return sequence | delays_each_on(sched1, 10ms); });
 
     int count = 0;
 
     auto v = ex::sync_wait(
-      ex::when_all(
-        with_void(stop_after_on(sched1, 50ms)),
-        ignore_all_values(
-          merged | continues_each_on(sched0) // serializes output on the sched0 strand
-          | then_each([&count, elapsed_ms](int x) {
-              ++count;
-              UNSCOPED_INFO(
-                "item: " << x << ", arrived at: " << std::setw(3) << elapsed_ms()
-                         << "ms, on thread id: " << std::this_thread::get_id());
-              return count;
-            }))));
+      ex::when_all(with_void(stop_after_on(sched1, 50ms)),
+                   ignore_all_values(
+                     merged | continues_each_on(sched0)  // serializes output on the sched0 strand
+                     | then_each(
+                       [&count, elapsed_ms](int x)
+                       {
+                         ++count;
+                         UNSCOPED_INFO("item: " << x << ", arrived at: " << std::setw(3)
+                                                << elapsed_ms() << "ms, on thread id: "
+                                                << std::this_thread::get_id());
+                         return count;
+                       }))));
 
     CAPTURE(count < 40, count > 4);
     CHECK(v.has_value() == false);
   }
 
-  TEST_CASE(
-    "merge_each - merge_each sender stops while merging all items from multiple threads",
-    "[sequence_senders][single_thread_context][merge_each][merge][iterate]") {
-
+  TEST_CASE("merge_each - merge_each sender stops while merging all items from multiple threads",
+            "[sequence_senders][single_thread_context][merge_each][merge][iterate]")
+  {
     exec::single_thread_context ctx0;
-    ex::scheduler auto sched0 = ctx0.get_scheduler();
-    exec::timed_thread_context ctx1;
-    ex::scheduler auto sched1 = ctx1.get_scheduler();
-    auto origin = now(sched1);
+    ex::scheduler auto          sched0 = ctx0.get_scheduler();
+    exec::timed_thread_context  ctx1;
+    ex::scheduler auto          sched1 = ctx1.get_scheduler();
+    auto                        origin = now(sched1);
 
-    auto elapsed_ms = [&sched1, origin]() {
+    auto elapsed_ms = [&sched1, origin]()
+    {
       using namespace std::chrono;
       return duration_cast<milliseconds>(now(sched1) - origin).count();
     };
 
-    auto stop_after_on = [sched0, elapsed_ms](auto sched, auto after) {
+    auto stop_after_on = [sched0, elapsed_ms](auto sched, auto after)
+    {
       return schedule_after(sched, after)
-           | STDEXEC::continues_on(sched0) // serializes output on the sched0 strand
-           | STDEXEC::let_value([elapsed_ms]() noexcept {
-               UNSCOPED_INFO(
-                 "requesting stop  - at: " << std::setw(3) << elapsed_ms()
-                                           << "ms, on thread id: " << std::this_thread::get_id());
-               return ex::just_stopped();
-             });
+           | STDEXEC::continues_on(sched0)  // serializes output on the sched0 strand
+           | STDEXEC::let_value(
+               [elapsed_ms]() noexcept
+               {
+                 UNSCOPED_INFO("requesting stop  - at: " << std::setw(3) << elapsed_ms()
+                                                         << "ms, on thread id: "
+                                                         << std::this_thread::get_id());
+                 return ex::just_stopped();
+               });
     };
 
-    auto error_after_on = [sched0, elapsed_ms](auto sched, auto after, auto error) {
+    auto error_after_on = [sched0, elapsed_ms](auto sched, auto after, auto error)
+    {
       return schedule_after(sched, after)
-           | STDEXEC::continues_on(sched0) // serializes output on the sched0 strand
-           | STDEXEC::let_value([elapsed_ms, error]() noexcept {
-               UNSCOPED_INFO(
-                 error.what() << " - at: " << std::setw(3) << elapsed_ms()
-                              << "ms, on thread id: " << std::this_thread::get_id());
-               return ex::just_error(error);
-             });
+           | STDEXEC::continues_on(sched0)  // serializes output on the sched0 strand
+           | STDEXEC::let_value(
+               [elapsed_ms, error]() noexcept
+               {
+                 UNSCOPED_INFO(error.what() << " - at: " << std::setw(3) << elapsed_ms()
+                                            << "ms, on thread id: " << std::this_thread::get_id());
+                 return ex::just_error(error);
+               });
     };
 
     // a sequence whose items are sequences
     auto sequences = merge(
-      ex::just(stop_after_on(sched1, 10ms)),                                         // no items
-      ex::just(range(100, 120)),                                                     // int items
-      ex::just(empty_sequence()),                                                    // no items
-      ex::just(range(200, 220)),                                                     // int items
-      ex::just(error_after_on(sched1, 50ms, std::runtime_error{"failed sequence "})) // no items
+      ex::just(stop_after_on(sched1, 10ms)),                                          // no items
+      ex::just(range(100, 120)),                                                      // int items
+      ex::just(empty_sequence()),                                                     // no items
+      ex::just(range(200, 220)),                                                      // int items
+      ex::just(error_after_on(sched1, 50ms, std::runtime_error{"failed sequence "}))  // no items
     );
 
     // apply delays_each_on to every sequence item and
     // merge all the new sequences
-    auto merged = sequences | flat_map([sched1](auto sequence) {
-                    return sequence | delays_each_on(sched1, 10ms);
-                  });
+    auto merged = sequences
+                | flat_map([sched1](auto sequence)
+                           { return sequence | delays_each_on(sched1, 10ms); });
 
     int count = 0;
 
     auto v = ex::sync_wait(
-      ex::when_all(
-        with_void(stop_after_on(sched1, 40ms)),
-        ignore_all_values(
-          merged | continues_each_on(sched0) // serializes output on the sched0 strand
-          | then_each([&count, elapsed_ms](int x) {
-              ++count;
-              UNSCOPED_INFO(
-                "item: " << x << ", arrived at: " << std::setw(3) << elapsed_ms()
-                         << "ms, on thread id: " << std::this_thread::get_id());
-              return count;
-            }))));
+      ex::when_all(with_void(stop_after_on(sched1, 40ms)),
+                   ignore_all_values(
+                     merged | continues_each_on(sched0)  // serializes output on the sched0 strand
+                     | then_each(
+                       [&count, elapsed_ms](int x)
+                       {
+                         ++count;
+                         UNSCOPED_INFO("item: " << x << ", arrived at: " << std::setw(3)
+                                                << elapsed_ms() << "ms, on thread id: "
+                                                << std::this_thread::get_id());
+                         return count;
+                       }))));
 
     CAPTURE(count < 40, count > 4);
     CHECK(v.has_value() == false);
   }
 
-#endif // STDEXEC_HAS_STD_RANGES()
+#endif  // STDEXEC_HAS_STD_RANGES()
 
-} // namespace
+}  // namespace
diff --git a/test/exec/sequence/test_transform_each.cpp b/test/exec/sequence/test_transform_each.cpp
index 19116dcc5..4cd082560 100644
--- a/test/exec/sequence/test_transform_each.cpp
+++ b/test/exec/sequence/test_transform_each.cpp
@@ -27,47 +27,47 @@
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
-namespace {
+namespace
+{
 
-  struct next_rcvr {
+  struct next_rcvr
+  {
     using receiver_concept = ex::receiver_t;
 
-    auto set_next(auto item) {
+    auto set_next(auto item)
+    {
       return item;
     }
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
   };
 
-  TEST_CASE(
-    "transform_each - transform sender applies adaptor to no elements",
-    "[sequence_senders][transform_each][empty_sequence]") {
-    int counter = 0;
-    auto transformed = exec::transform_each(exec::empty_sequence(), ex::then([&counter]() noexcept {
-                                              ++counter;
-                                            }));
-    auto op = exec::subscribe(transformed, next_rcvr{});
+  TEST_CASE("transform_each - transform sender applies adaptor to no elements",
+            "[sequence_senders][transform_each][empty_sequence]")
+  {
+    int  counter     = 0;
+    auto transformed = exec::transform_each(exec::empty_sequence(),
+                                            ex::then([&counter]() noexcept { ++counter; }));
+    auto op          = exec::subscribe(transformed, next_rcvr{});
     ex::start(op);
     CHECK(counter == 0);
   }
 
-  TEST_CASE(
-    "transform_each - transform sender applies adaptor to a sender",
-    "[sequence_senders][transform_each]") {
-    int value = 0;
-    auto transformed = exec::transform_each(ex::just(42), ex::then([&value](int x) noexcept {
-                                              value = x;
-                                            }));
-    auto op = exec::subscribe(transformed, next_rcvr{});
+  TEST_CASE("transform_each - transform sender applies adaptor to a sender",
+            "[sequence_senders][transform_each]")
+  {
+    int  value       = 0;
+    auto transformed = exec::transform_each(ex::just(42),
+                                            ex::then([&value](int x) noexcept { value = x; }));
+    auto op          = exec::subscribe(transformed, next_rcvr{});
     ex::start(op);
     CHECK(value == 42);
   }
 
-  TEST_CASE(
-    "transform_each - transform sender applies adaptor to a sender and ignores all values",
-    "[sequence_senders][transform_each][ignore_all_values]") {
-    int value = 0;
+  TEST_CASE("transform_each - transform sender applies adaptor to a sender and ignores all values",
+            "[sequence_senders][transform_each][ignore_all_values]")
+  {
+    int  value       = 0;
     auto transformed = exec::transform_each(ex::just(42), ex::then([&value](int x) { value = x; }))
                      | exec::ignore_all_values();
     ex::sync_wait(transformed);
@@ -75,36 +75,41 @@ namespace {
   }
 
 #if STDEXEC_HAS_STD_RANGES()
-  TEST_CASE(
-    "transform_each - transform sender applies adaptor to each item",
-    "[sequence_senders][transform_each][iterate]") {
-    auto range = [](auto from, auto to) {
+  TEST_CASE("transform_each - transform sender applies adaptor to each item",
+            "[sequence_senders][transform_each][iterate]")
+  {
+    auto range = [](auto from, auto to)
+    {
       return exec::iterate(std::views::iota(from, to));
     };
-    auto then_each = [](auto f) {
+    auto then_each = [](auto f)
+    {
       return exec::transform_each(ex::then(f));
     };
-    int total = 0;
-    auto sum = range(0, 10) | then_each([&total](int x) noexcept { total += x; });
+    int  total = 0;
+    auto sum   = range(0, 10) | then_each([&total](int x) noexcept { total += x; });
     ex::sync_wait(exec::ignore_all_values(sum));
     CHECK(total == 45);
   }
 #endif
 
-  struct my_domain {
+  struct my_domain
+  {
     template <ex::sender_expr_for<ex::then_t> Sender, class Env>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, const Env&) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender &&, Env const &)
+    {
       return ex::just(int{42});
     }
   };
 
-  TEST_CASE("transform_each - can be customized late", "[transform_each][ignore_all_values]") {
+  TEST_CASE("transform_each - can be customized late", "[transform_each][ignore_all_values]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<my_domain> sched;
-    int result = 0;
-    auto start = ex::just(std::string{"hello"});
+    int                               result = 0;
+    auto                              start  = ex::just(std::string{"hello"});
     auto with_scheduler = ex::write_env(ex::prop{ex::get_scheduler, inline_scheduler()});
-    auto adaptor = ex::on(sched, ex::then([](std::string x) { return x + ", world"; }))
+    auto adaptor        = ex::on(sched, ex::then([](std::string x) { return x + ", world"; }))
                  | with_scheduler;
     auto snd = start | exec::transform_each(adaptor)
              | exec::transform_each(ex::then([&](int x) { result = x; }))
@@ -112,4 +117,4 @@ namespace {
     ex::sync_wait(snd);
     CHECK(result == 42);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/taskflow/test_taskflow_thread_pool.cpp b/test/exec/taskflow/test_taskflow_thread_pool.cpp
index 8d1eb384b..ac485629c 100644
--- a/test/exec/taskflow/test_taskflow_thread_pool.cpp
+++ b/test/exec/taskflow/test_taskflow_thread_pool.cpp
@@ -26,16 +26,16 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
   // Example adapted from
   // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2300r5.html#example-async-inclusive-scan
   [[nodiscard]]
-  auto async_inclusive_scan(
-    STDEXEC::scheduler auto sch,                    // 2
-    std::span<const double> input,                  // 1
-    std::span<double> output,                       // 1
-    double init,                                    // 1
-    std::size_t tile_count) -> STDEXEC::sender auto // 3
+  auto async_inclusive_scan(STDEXEC::scheduler auto sch,                     // 2
+                            std::span<double const> input,                   // 1
+                            std::span<double>       output,                  // 1
+                            double                  init,                    // 1
+                            std::size_t             tile_count) -> STDEXEC::sender auto  // 3
   {
     using namespace STDEXEC;
     std::size_t const tile_size = (input.size() + tile_count - 1) / tile_count;
@@ -44,32 +44,33 @@ namespace {
     partials[0] = init;
 
     return just(std::move(partials)) | continues_on(sch)
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               partials[i + 1] = *--std::inclusive_scan(
-                 begin(input) + static_cast<long>(start),
-                 begin(input) + static_cast<long>(end),
-                 begin(output) + static_cast<long>(start));
-             }) //
-         | then([](std::vector<double>&& partials) {
-             std::inclusive_scan(begin(partials), end(partials), begin(partials));
-             return std::move(partials);
-           }) //
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<const double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               std::for_each(
-                 begin(output) + static_cast<long>(start),
-                 begin(output) + static_cast<long>(end),
-                 [&](double& e) { e = partials[i] + e; });
-             }) //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double> partials)
+                {
+                  auto start      = i * tile_size;
+                  auto end        = (std::min) (input.size(), (i + 1) * tile_size);
+                  partials[i + 1] = *--std::inclusive_scan(begin(input) + static_cast<long>(start),
+                                                           begin(input) + static_cast<long>(end),
+                                                           begin(output)
+                                                             + static_cast<long>(start));
+                })  //
+         | then(
+             [](std::vector<double>&& partials)
+             {
+               std::inclusive_scan(begin(partials), end(partials), begin(partials));
+               return std::move(partials);
+             })  //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double const> partials)
+                {
+                  auto start = i * tile_size;
+                  auto end   = (std::min) (input.size(), (i + 1) * tile_size);
+                  std::for_each(begin(output) + static_cast<long>(start),
+                                begin(output) + static_cast<long>(end),
+                                [&](double& e) { e = partials[i] + e; });
+                })  //
          | then([=](std::vector<double>&&) { return output; });
   }
 
@@ -77,17 +78,17 @@ namespace {
             "[taskflow_thread_pool]")
   {
     exec::taskflow::taskflow_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    CHECK(
-      ex::get_forward_progress_guarantee(pool_sched) == ex::forward_progress_guarantee::parallel);
+    auto                                 pool_sched = pool.get_scheduler();
+    CHECK(ex::get_forward_progress_guarantee(pool_sched)
+          == ex::forward_progress_guarantee::parallel);
   }
 
   TEST_CASE("STDEXEC::on works when changing threads with exec::taskflow::taskflow_thread_pool",
             "[taskflow_thread_pool]")
   {
     exec::taskflow::taskflow_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    bool called{false};
+    auto                                 pool_sched = pool.get_scheduler();
+    bool                                 called{false};
     // launch some work on the thread pool
     ex::sender auto snd = ex::starts_on(pool_sched, ex::just()) | ex::then([&] { called = true; });
     STDEXEC::sync_wait(std::move(snd));
@@ -95,12 +96,13 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE("more taskflow_thread_pool", "[taskflow_thread_pool]") {
+  TEST_CASE("more taskflow_thread_pool", "[taskflow_thread_pool]")
+  {
     using namespace STDEXEC;
 
     exec::taskflow::taskflow_thread_pool pool(1ul);
-    exec::static_thread_pool other_pool(1);
-    STDEXEC::inline_scheduler inline_sched;
+    exec::static_thread_pool             other_pool(1);
+    STDEXEC::inline_scheduler            inline_sched;
 
     // Get a handle to the thread pool:
     auto other_sched = other_pool.get_scheduler();
@@ -108,7 +110,8 @@ namespace {
     // Get a handle to the thread pool:
     auto taskflow_sched = pool.get_scheduler();
 
-    auto compute = [](int x) -> int {
+    auto compute = [](int x) -> int
+    {
       return x + 1;
     };
 
@@ -127,41 +130,38 @@ namespace {
     CHECK(k == 5);
   }
 
-  TEST_CASE("taskflow_thread_pool exceptions", "[taskflow_thread_pool]") {
+  TEST_CASE("taskflow_thread_pool exceptions", "[taskflow_thread_pool]")
+  {
     using namespace STDEXEC;
 
     exec::taskflow::taskflow_thread_pool taskflow_pool;
-    exec::static_thread_pool other_pool(1ul);
+    exec::static_thread_pool             other_pool(1ul);
     {
-      CHECK_THROWS(
-        STDEXEC::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0)) | then([](auto) {
-                             throw std::exception();
-                           })));
-      CHECK_THROWS(
-        STDEXEC::sync_wait(starts_on(other_pool.get_scheduler(), just(0)) | then([](auto) {
-                             throw std::exception();
-                           })));
+      CHECK_THROWS(STDEXEC::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0))
+                                      | then([](auto) { throw std::exception(); })));
+      CHECK_THROWS(STDEXEC::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                      | then([](auto) { throw std::exception(); })));
     }
     // Ensure it still works normally after exceptions:
     {
-      auto tbb_result = STDEXEC::sync_wait(
-        starts_on(taskflow_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto tbb_result = STDEXEC::sync_wait(starts_on(taskflow_pool.get_scheduler(), just(0))
+                                           | then([](auto i) { return i + 1; }));
       CHECK(tbb_result.has_value());
-      auto other_result = STDEXEC::sync_wait(
-        starts_on(other_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto other_result = STDEXEC::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                             | then([](auto i) { return i + 1; }));
       CHECK(tbb_result == other_result);
     }
   }
 
-  TEST_CASE("taskflow_thread_pool async_inclusive_scan", "[taskflow_thread_pool]") {
-    const auto input = std::array{1.0, 2.0, -1.0, -2.0};
+  TEST_CASE("taskflow_thread_pool async_inclusive_scan", "[taskflow_thread_pool]")
+  {
+    auto const                           input = std::array{1.0, 2.0, -1.0, -2.0};
     std::remove_const_t<decltype(input)> output;
     exec::taskflow::taskflow_thread_pool pool{2ul};
-    auto [value] = STDEXEC::sync_wait(
-                     async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4))
-                     .value();
+    auto [value] =
+      STDEXEC::sync_wait(async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4)).value();
     STATIC_REQUIRE(std::is_same_v<decltype(value), std::span<double>>);
     REQUIRE(value.data() == output.data());
     CHECK(output == std::array{1.0, 3.0, 2.0, 0.0});
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/tbb/test_tbb_thread_pool.cpp b/test/exec/tbb/test_tbb_thread_pool.cpp
index 799cc2ff5..7052e40e0 100644
--- a/test/exec/tbb/test_tbb_thread_pool.cpp
+++ b/test/exec/tbb/test_tbb_thread_pool.cpp
@@ -28,16 +28,16 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
   // Example adapted from
   // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2300r5.html#example-async-inclusive-scan
   [[nodiscard]]
-  auto async_inclusive_scan(
-    ex::scheduler auto sch,                    // 2
-    std::span<const double> input,             // 1
-    std::span<double> output,                  // 1
-    double init,                               // 1
-    std::size_t tile_count) -> ex::sender auto // 3
+  auto async_inclusive_scan(ex::scheduler auto      sch,                // 2
+                            std::span<double const> input,              // 1
+                            std::span<double>       output,             // 1
+                            double                  init,               // 1
+                            std::size_t             tile_count) -> ex::sender auto  // 3
   {
     using namespace STDEXEC;
     std::size_t const tile_size = (input.size() + tile_count - 1) / tile_count;
@@ -45,33 +45,34 @@ namespace {
     std::vector<double> partials(tile_count + 1);
     partials[0] = init;
 
-    return just(std::move(partials)) | continues_on(sch) //
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               partials[i + 1] = *--std::inclusive_scan(
-                 begin(input) + static_cast<long>(start),
-                 begin(input) + static_cast<long>(end),
-                 begin(output) + static_cast<long>(start));
-             }) //
-         | then([](std::vector<double>&& partials) {
-             std::inclusive_scan(begin(partials), end(partials), begin(partials));
-             return std::move(partials);
-           }) //
-         | bulk(
-             ex::par,
-             tile_count,
-             [=](std::size_t i, std::span<const double> partials) {
-               auto start = i * tile_size;
-               auto end = (std::min) (input.size(), (i + 1) * tile_size);
-               std::for_each(
-                 begin(output) + static_cast<long>(start),
-                 begin(output) + static_cast<long>(end),
-                 [&](double& e) { e = partials[i] + e; });
-             }) //
+    return just(std::move(partials)) | continues_on(sch)  //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double> partials)
+                {
+                  auto start      = i * tile_size;
+                  auto end        = (std::min) (input.size(), (i + 1) * tile_size);
+                  partials[i + 1] = *--std::inclusive_scan(begin(input) + static_cast<long>(start),
+                                                           begin(input) + static_cast<long>(end),
+                                                           begin(output)
+                                                             + static_cast<long>(start));
+                })  //
+         | then(
+             [](std::vector<double>&& partials)
+             {
+               std::inclusive_scan(begin(partials), end(partials), begin(partials));
+               return std::move(partials);
+             })  //
+         | bulk(ex::par,
+                tile_count,
+                [=](std::size_t i, std::span<double const> partials)
+                {
+                  auto start = i * tile_size;
+                  auto end   = (std::min) (input.size(), (i + 1) * tile_size);
+                  std::for_each(begin(output) + static_cast<long>(start),
+                                begin(output) + static_cast<long>(end),
+                                [&](double& e) { e = partials[i] + e; });
+                })  //
          | then([=](std::vector<double>&&) { return output; });
   }
 
@@ -79,17 +80,17 @@ namespace {
             "[tbb_thread_pool]")
   {
     exec::tbb::tbb_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    CHECK(
-      ex::get_forward_progress_guarantee(pool_sched) == ex::forward_progress_guarantee::parallel);
+    auto                       pool_sched = pool.get_scheduler();
+    CHECK(ex::get_forward_progress_guarantee(pool_sched)
+          == ex::forward_progress_guarantee::parallel);
   }
 
   TEST_CASE("ex::on works when changing threads with exec::tbb::tbb_thread_pool",
             "[tbb_thread_pool]")
   {
     exec::tbb::tbb_thread_pool pool;
-    auto pool_sched = pool.get_scheduler();
-    bool called{false};
+    auto                       pool_sched = pool.get_scheduler();
+    bool                       called{false};
     // launch some work on the thread pool
     ex::sender auto snd = ex::on(pool_sched, ex::just()) | ex::then([&] { called = true; });
     ex::sync_wait(std::move(snd));
@@ -97,12 +98,13 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE("more tbb_thread_pool", "[tbb_thread_pool]") {
+  TEST_CASE("more tbb_thread_pool", "[tbb_thread_pool]")
+  {
     using namespace STDEXEC;
 
     exec::tbb::tbb_thread_pool pool(1);
-    exec::static_thread_pool other_pool(1);
-    STDEXEC::inline_scheduler inline_sched;
+    exec::static_thread_pool   other_pool(1);
+    STDEXEC::inline_scheduler  inline_sched;
 
     // Get a handle to the thread pool:
     auto other_sched = other_pool.get_scheduler();
@@ -110,7 +112,8 @@ namespace {
     // Get a handle to the thread pool:
     auto tbb_sched = pool.get_scheduler();
 
-    auto compute = [](int x) -> int {
+    auto compute = [](int x) -> int
+    {
       return x + 1;
     };
 
@@ -130,41 +133,41 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("tbb_thread_pool exceptions", "[tbb_thread_pool]") {
+  TEST_CASE("tbb_thread_pool exceptions", "[tbb_thread_pool]")
+  {
     // I know tbb::task_groups do cancellation with exceptions, which leaves them in a not-restartable
     // state. We'd better have it act normally here.
     using namespace STDEXEC;
 
     exec::tbb::tbb_thread_pool tbb_pool;
-    exec::static_thread_pool other_pool(1);
+    exec::static_thread_pool   other_pool(1);
     {
-      CHECK_THROWS(ex::sync_wait(starts_on(tbb_pool.get_scheduler(), just(0)) | then([](auto) {
-                                   throw std::exception();
-                                 })));
-      CHECK_THROWS(ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0)) | then([](auto) {
-                                   throw std::exception();
-                                 })));
+      CHECK_THROWS(ex::sync_wait(starts_on(tbb_pool.get_scheduler(), just(0))
+                                 | then([](auto) { throw std::exception(); })));
+      CHECK_THROWS(ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                 | then([](auto) { throw std::exception(); })));
     }
     // Ensure it still works normally after exceptions:
     {
-      auto tbb_result = ex::sync_wait(
-        starts_on(tbb_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto tbb_result = ex::sync_wait(starts_on(tbb_pool.get_scheduler(), just(0))
+                                      | then([](auto i) { return i + 1; }));
       CHECK(tbb_result.has_value());
-      auto other_result = ex::sync_wait(
-        starts_on(other_pool.get_scheduler(), just(0)) | then([](auto i) { return i + 1; }));
+      auto other_result = ex::sync_wait(starts_on(other_pool.get_scheduler(), just(0))
+                                        | then([](auto i) { return i + 1; }));
       CHECK(tbb_result == other_result);
     }
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("tbb_thread_pool async_inclusive_scan", "[tbb_thread_pool]") {
-    const auto input = std::array{1.0, 2.0, -1.0, -2.0};
+  TEST_CASE("tbb_thread_pool async_inclusive_scan", "[tbb_thread_pool]")
+  {
+    auto const                           input = std::array{1.0, 2.0, -1.0, -2.0};
     std::remove_const_t<decltype(input)> output;
     exec::tbb::tbb_thread_pool           pool{2};
-    auto [value] = ex::sync_wait(async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4))
-                     .value();
+    auto [value] =
+      ex::sync_wait(async_inclusive_scan(pool.get_scheduler(), input, output, 0.0, 4)).value();
     STATIC_REQUIRE(std::is_same_v<decltype(value), std::span<double>>);
     REQUIRE(value.data() == output.data());
     CHECK(output == std::array{1.0, 3.0, 2.0, 0.0});
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_any_sender.cpp b/test/exec/test_any_sender.cpp
index f41f0d7b1..298dada4c 100644
--- a/test/exec/test_any_sender.cpp
+++ b/test/exec/test_any_sender.cpp
@@ -17,9 +17,9 @@
 #include <exec/any_sender_of.hpp>
 #include <exec/env.hpp>
 #include <exec/inline_scheduler.hpp>
+#include <exec/split.hpp>
 #include <exec/static_thread_pool.hpp>
 #include <exec/when_any.hpp>
-#include <exec/split.hpp>
 #include <stdexec/stop_token.hpp>
 
 #include <test_common/receivers.hpp>
@@ -30,78 +30,89 @@
 namespace ex = STDEXEC;
 
 STDEXEC_PRAGMA_PUSH()
-STDEXEC_PRAGMA_IGNORE_MSVC(4702) // unreachable code
+STDEXEC_PRAGMA_IGNORE_MSVC(4702)  // unreachable code
 
-namespace {
+namespace
+{
 
   ///////////////////////////////////////////////////////////////////////////////
   //                                                             exec::any_receiver_ref
 
-  struct get_address_t : ex::__query<get_address_t> { };
+  struct get_address_t : ex::__query<get_address_t>
+  {};
 
   inline constexpr get_address_t get_address;
 
-  struct env {
-    const void* object_{nullptr};
+  struct env
+  {
+    void const            *object_{nullptr};
     ex::inplace_stop_token token_{};
 
     [[nodiscard]]
-    auto query(get_address_t) const noexcept -> const void* {
+    auto query(get_address_t) const noexcept -> void const *
+    {
       return object_;
     }
 
     [[nodiscard]]
-    auto query(ex::get_stop_token_t) const noexcept -> ex::inplace_stop_token {
+    auto query(ex::get_stop_token_t) const noexcept -> ex::inplace_stop_token
+    {
       return token_;
     }
   };
 
-  struct sink_receiver {
+  struct sink_receiver
+  {
     using receiver_concept = ex::receiver_t;
 
     std::variant<std::monostate, int, std::exception_ptr, ex::set_stopped_t> value_{};
 
-    void set_value(int value) noexcept {
+    void set_value(int value) noexcept
+    {
       value_ = value;
     }
 
-    void set_error(std::exception_ptr e) noexcept {
+    void set_error(std::exception_ptr e) noexcept
+    {
       value_ = e;
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       value_ = ex::set_stopped_t();
     }
 
     [[nodiscard]]
-    auto get_env() const noexcept -> env {
-      return {.object_ = static_cast<const void*>(this)};
+    auto get_env() const noexcept -> env
+    {
+      return {.object_ = static_cast<void const *>(this)};
     }
   };
 
-  TEST_CASE("exec::any_receiver_ref is constructible from receivers", "[types][any_sender]") {
+  TEST_CASE("exec::any_receiver_ref is constructible from receivers", "[types][any_sender]")
+  {
     using Sigs = ex::completion_signatures<ex::set_value_t(int)>;
-    sink_receiver rcvr;
+    sink_receiver                rcvr;
     exec::any_receiver_ref<Sigs> ref{rcvr};
     CHECK(ex::receiver<decltype(ref)>);
     CHECK(ex::receiver_of<decltype(ref), Sigs>);
     CHECK(!ex::receiver_of<decltype(ref), ex::completion_signatures<ex::set_value_t()>>);
     CHECK(std::is_copy_assignable_v<exec::any_receiver_ref<Sigs>>);
-    CHECK(std::is_constructible_v<exec::any_receiver_ref<Sigs>, const sink_receiver&>);
-    CHECK(!std::is_constructible_v<exec::any_receiver_ref<Sigs>, sink_receiver&&>);
-    CHECK(!std::is_constructible_v<
-          exec::any_receiver_ref<ex::completion_signatures<ex::set_value_t()>>,
-          const sink_receiver&
-    >);
+    CHECK(std::is_constructible_v<exec::any_receiver_ref<Sigs>, sink_receiver const &>);
+    CHECK(!std::is_constructible_v<exec::any_receiver_ref<Sigs>, sink_receiver &&>);
+    CHECK(
+      !std::is_constructible_v<exec::any_receiver_ref<ex::completion_signatures<ex::set_value_t()>>,
+                               sink_receiver const &>);
   }
 
-  TEST_CASE("exec::any_receiver_ref is queryable", "[types][any_sender]") {
-    using Sigs = ex::completion_signatures<ex::set_value_t(int)>;
-    using receiver_ref = exec::any_receiver_ref<Sigs, get_address.signature<const void*()>>;
+  TEST_CASE("exec::any_receiver_ref is queryable", "[types][any_sender]")
+  {
+    using Sigs         = ex::completion_signatures<ex::set_value_t(int)>;
+    using receiver_ref = exec::any_receiver_ref<Sigs, get_address.signature<void const *()>>;
     sink_receiver rcvr1{};
     sink_receiver rcvr2{};
-    receiver_ref ref1{rcvr1};
-    receiver_ref ref2{rcvr2};
+    receiver_ref  ref1{rcvr1};
+    receiver_ref  ref2{rcvr2};
     CHECK(get_address(ex::get_env(ref1)) == &rcvr1);
     CHECK(get_address(ex::get_env(ref2)) == &rcvr2);
     {
@@ -119,9 +130,11 @@ namespace {
     CHECK(get_address(ex::get_env(ref1)) == &rcvr2);
   }
 
-  TEST_CASE("exec::any_receiver_ref calls ex::receiver methods", "[types][any_sender]") {
-    using Sigs =
-      ex::completion_signatures<ex::set_value_t(int), ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>;
+  TEST_CASE("exec::any_receiver_ref calls ex::receiver methods", "[types][any_sender]")
+  {
+    using Sigs         = ex::completion_signatures<ex::set_value_t(int),
+                                                   ex::set_error_t(std::exception_ptr),
+                                                   ex::set_stopped_t()>;
     using receiver_ref = exec::any_receiver_ref<Sigs>;
     REQUIRE(ex::receiver_of<receiver_ref, Sigs>);
     sink_receiver value{};
@@ -131,13 +144,13 @@ namespace {
     // Check set value
     CHECK(value.value_.index() == 0);
     receiver_ref ref = value;
-    ex::set_value(static_cast<receiver_ref&&>(ref), 42);
+    ex::set_value(static_cast<receiver_ref &&>(ref), 42);
     CHECK(value.value_.index() == 1);
     CHECK(std::get<1>(value.value_) == 42);
     // Check set error
     CHECK(error.value_.index() == 0);
     ref = error;
-    ex::set_error(static_cast<receiver_ref&&>(ref), std::make_exception_ptr(42));
+    ex::set_error(static_cast<receiver_ref &&>(ref), std::make_exception_ptr(42));
     CHECK(error.value_.index() == 2);
 #if !STDEXEC_NO_STD_EXCEPTIONS()
     // MSVC issues a warning about unreachable code in this block, hence the warning
@@ -147,16 +160,17 @@ namespace {
     // Check set stopped
     CHECK(stopped.value_.index() == 0);
     ref = stopped;
-    ex::set_stopped(static_cast<receiver_ref&&>(ref));
+    ex::set_stopped(static_cast<receiver_ref &&>(ref));
     CHECK(stopped.value_.index() == 3);
   }
 
-  TEST_CASE("exec::any_receiver_ref is connectable with exec::when_any", "[types][any_sender]") {
-    using Sigs = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
+  TEST_CASE("exec::any_receiver_ref is connectable with exec::when_any", "[types][any_sender]")
+  {
+    using Sigs         = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
     using receiver_ref = exec::any_receiver_ref<Sigs>;
     REQUIRE(ex::receiver_of<receiver_ref, Sigs>);
     sink_receiver rcvr{};
-    receiver_ref ref = rcvr;
+    receiver_ref  ref = rcvr;
 
     auto sndr = exec::when_any(ex::just(42));
     CHECK(rcvr.value_.index() == 0);
@@ -169,16 +183,20 @@ namespace {
   ///////////////////////////////////////////////////////////////////////////////
   //                                                                any.storage
 
-  struct empty_vtable_t {
+  struct empty_vtable_t
+  {
     template <class T>
-    static auto __create_vtable(ex::__mtype<T>) noexcept -> empty_vtable_t* {
+    static auto __create_vtable(ex::__mtype<T>) noexcept -> empty_vtable_t *
+    {
       static empty_vtable_t vtable{};
       return &vtable;
     }
   };
 
-  TEST_CASE("empty storage is movable", "[types][any_sender]") {
-    struct foo { };
+  TEST_CASE("empty storage is movable", "[types][any_sender]")
+  {
+    struct foo
+    {};
 
     using any_unique = exec::__any::__unique_storage_t<empty_vtable_t>;
     any_unique s1{};
@@ -192,7 +210,7 @@ namespace {
     CHECK(s2.__get_object_pointer() != nullptr);
     // Test SBO
     auto obj_ptr = reinterpret_cast<std::intptr_t>(s2.__get_object_pointer());
-    auto s2_ptr = reinterpret_cast<std::intptr_t>(&s2);
+    auto s2_ptr  = reinterpret_cast<std::intptr_t>(&s2);
     CHECK(std::abs(s2_ptr - obj_ptr) < std::intptr_t(sizeof(any_unique)));
 
     s1 = std::move(s2);
@@ -206,14 +224,16 @@ namespace {
     CHECK(s2.__get_object_pointer() == nullptr);
   }
 
-  TEST_CASE("empty storage is movable, throwing moves will allocate", "[types][any_sender]") {
-    struct move_throws {
+  TEST_CASE("empty storage is movable, throwing moves will allocate", "[types][any_sender]")
+  {
+    struct move_throws
+    {
       move_throws() = default;
 
-      move_throws(move_throws&&) noexcept(false) {
-      }
+      move_throws(move_throws &&) noexcept(false) {}
 
-      auto operator=(move_throws&&) noexcept(false) -> move_throws& {
+      auto operator=(move_throws &&) noexcept(false) -> move_throws &
+      {
         return *this;
       }
     };
@@ -230,7 +250,7 @@ namespace {
     CHECK(s2.__get_object_pointer() != nullptr);
     // Test SBO
     auto obj_ptr = reinterpret_cast<std::intptr_t>(s2.__get_object_pointer());
-    auto s2_ptr = reinterpret_cast<std::intptr_t>(&s2);
+    auto s2_ptr  = reinterpret_cast<std::intptr_t>(&s2);
     CHECK(std::abs(s2_ptr - obj_ptr) >= std::intptr_t(sizeof(any_unique)));
 
     s1 = std::move(s2);
@@ -248,9 +268,11 @@ namespace {
   //                                                                any_sender
 
   template <class... Ts>
-  using any_sender_of = exec::any_receiver_ref<ex::completion_signatures<Ts...>>::template any_sender<>;
+  using any_sender_of =
+    exec::any_receiver_ref<ex::completion_signatures<Ts...>>::template any_sender<>;
 
-  TEST_CASE("any sender is a sender", "[types][any_sender]") {
+  TEST_CASE("any sender is a sender", "[types][any_sender]")
+  {
     CHECK(ex::sender<any_sender_of<ex::set_value_t()>>);
     CHECK(std::is_move_assignable_v<any_sender_of<ex::set_value_t()>>);
     CHECK(std::is_nothrow_move_assignable_v<any_sender_of<ex::set_value_t()>>);
@@ -258,32 +280,33 @@ namespace {
     any_sender_of<ex::set_value_t()> sender = ex::just();
   }
 
-  TEST_CASE("ex::sync_wait works on any_sender_of", "[types][any_sender]") {
-    int value = 0;
-    any_sender_of<ex::set_value_t()> sender = ex::just(42) | ex::then([&](int v) noexcept { value = v; });
-    CHECK(
-      std::same_as<
-        ex::completion_signatures_of_t<any_sender_of<ex::set_value_t()>>,
-        ex::completion_signatures<ex::set_value_t()>
-      >);
+  TEST_CASE("ex::sync_wait works on any_sender_of", "[types][any_sender]")
+  {
+    int                              value  = 0;
+    any_sender_of<ex::set_value_t()> sender = ex::just(42)
+                                            | ex::then([&](int v) noexcept { value = v; });
+    CHECK(std::same_as<ex::completion_signatures_of_t<any_sender_of<ex::set_value_t()>>,
+                       ex::completion_signatures<ex::set_value_t()>>);
     ex::sync_wait(std::move(sender));
     CHECK(value == 42);
   }
 
-  TEST_CASE("construct any_sender_of recursively from ex::when_all", "[types][any_sender]") {
-    any_sender_of<ex::set_value_t(), ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)> sender = ex::just();
-    using sender_t = any_sender_of<ex::set_value_t(), ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>;
+  TEST_CASE("construct any_sender_of recursively from ex::when_all", "[types][any_sender]")
+  {
+    any_sender_of<ex::set_value_t(), ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>
+      sender = ex::just();
+    using sender_t =
+      any_sender_of<ex::set_value_t(), ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>;
     using when_all_t = decltype(ex::when_all(std::move(sender)));
-    static_assert(std::is_constructible_v<sender_t, when_all_t&&>);
+    static_assert(std::is_constructible_v<sender_t, when_all_t &&>);
   }
 
-  TEST_CASE("ex::sync_wait returns value", "[types][any_sender]") {
-    any_sender_of<ex::set_value_t(int)> sender = ex::just(21) | ex::then([&](int v) noexcept { return 2 * v; });
-    CHECK(
-      std::same_as<
-        ex::completion_signatures_of_t<any_sender_of<ex::set_value_t(int)>>,
-        ex::completion_signatures<ex::set_value_t(int)>
-      >);
+  TEST_CASE("ex::sync_wait returns value", "[types][any_sender]")
+  {
+    any_sender_of<ex::set_value_t(int)> sender = ex::just(21)
+                                               | ex::then([&](int v) noexcept { return 2 * v; });
+    CHECK(std::same_as<ex::completion_signatures_of_t<any_sender_of<ex::set_value_t(int)>>,
+                       ex::completion_signatures<ex::set_value_t(int)>>);
     auto [value1] = *ex::sync_wait(std::move(sender));
     CHECK(value1 == 42);
   }
@@ -292,26 +315,28 @@ namespace {
   using my_sender_of = any_sender_of<ex::set_value_t(Vals)..., ex::set_error_t(std::exception_ptr)>;
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("ex::sync_wait returns value and exception", "[types][any_sender]") {
+  TEST_CASE("ex::sync_wait returns value and exception", "[types][any_sender]")
+  {
     my_sender_of<int> sender = ex::just(21) | ex::then([&](int v) { return 2 * v; });
-    auto [value] = *ex::sync_wait(std::move(sender));
+    auto [value]             = *ex::sync_wait(std::move(sender));
     CHECK(value == 42);
 
     sender = ex::just(21) | ex::then([&](int) -> int { throw 420; });
     CHECK_THROWS_AS(ex::sync_wait(std::move(sender)), int);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("any_sender is connectable with exec::any_receiver_ref", "[types][any_sender]") {
-    using Sigs = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
+  TEST_CASE("any_sender is connectable with exec::any_receiver_ref", "[types][any_sender]")
+  {
+    using Sigs         = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
     using receiver_ref = exec::any_receiver_ref<Sigs>;
-    using sender = receiver_ref::any_sender<>;
+    using sender       = receiver_ref::any_sender<>;
     REQUIRE(ex::receiver_of<receiver_ref, Sigs>);
     sender sndr = ex::just_stopped();
     {
       sink_receiver rcvr{};
-      receiver_ref ref = rcvr;
-      auto op = ex::connect(std::move(sndr), std::move(ref));
+      receiver_ref  ref = rcvr;
+      auto          op  = ex::connect(std::move(sndr), std::move(ref));
       CHECK(rcvr.value_.index() == 0);
       ex::start(op);
       CHECK(rcvr.value_.index() == 3);
@@ -319,8 +344,8 @@ namespace {
     sndr = ex::just(42);
     {
       sink_receiver rcvr{};
-      receiver_ref ref = rcvr;
-      auto op = ex::connect(std::move(sndr), std::move(ref));
+      receiver_ref  ref = rcvr;
+      auto          op  = ex::connect(std::move(sndr), std::move(ref));
       CHECK(rcvr.value_.index() == 0);
       ex::start(op);
       CHECK(rcvr.value_.index() == 1);
@@ -328,8 +353,8 @@ namespace {
     sndr = exec::when_any(ex::just(42));
     {
       sink_receiver rcvr{};
-      receiver_ref ref = rcvr;
-      auto op = ex::connect(std::move(sndr), std::move(ref));
+      receiver_ref  ref = rcvr;
+      auto          op  = ex::connect(std::move(sndr), std::move(ref));
       CHECK(rcvr.value_.index() == 0);
       ex::start(op);
       CHECK(rcvr.value_.index() == 1);
@@ -337,14 +362,17 @@ namespace {
   }
 
   template <class... Vals>
-  using my_stoppable_sender_of =
-    any_sender_of<ex::set_value_t(Vals)..., ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>;
+  using my_stoppable_sender_of = any_sender_of<ex::set_value_t(Vals)...,
+                                               ex::set_error_t(std::exception_ptr),
+                                               ex::set_stopped_t()>;
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("any_sender uses overload rules for completion signatures", "[types][any_sender]") {
+  TEST_CASE("any_sender uses overload rules for completion signatures", "[types][any_sender]")
+  {
     auto split_sender = exec::split(ex::just(42));
-    static_assert(ex::sender_of<decltype(split_sender), ex::set_error_t(const std::exception_ptr&)>);
-    static_assert(ex::sender_of<decltype(split_sender), ex::set_value_t(const int&)>);
+    static_assert(
+      ex::sender_of<decltype(split_sender), ex::set_error_t(std::exception_ptr const &)>);
+    static_assert(ex::sender_of<decltype(split_sender), ex::set_value_t(int const &)>);
     my_stoppable_sender_of<int> sender = split_sender;
 
     auto [value] = *ex::sync_wait(std::move(sender));
@@ -353,17 +381,21 @@ namespace {
     sender = ex::just(21) | ex::then([&](int) -> int { throw 420; });
     CHECK_THROWS_AS(ex::sync_wait(std::move(sender)), int);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  class stopped_token {
+  class stopped_token
+  {
    private:
     bool stopped_{true};
 
-    struct __callback_type {
+    struct __callback_type
+    {
       template <class Fn>
-      explicit __callback_type(stopped_token t, Fn&& f) noexcept {
-        if (t.stopped_) {
-          static_cast<Fn&&>(f)();
+      explicit __callback_type(stopped_token t, Fn &&f) noexcept
+      {
+        if (t.stopped_)
+        {
+          static_cast<Fn &&>(f)();
         }
       }
     };
@@ -371,59 +403,68 @@ namespace {
     constexpr stopped_token() noexcept = default;
 
     explicit constexpr stopped_token(bool stopped) noexcept
-      : stopped_{stopped} {
-    }
+      : stopped_{stopped}
+    {}
 
     template <class>
     using callback_type = __callback_type;
 
-    static auto stop_requested() noexcept -> std::true_type {
+    static auto stop_requested() noexcept -> std::true_type
+    {
       return {};
     }
 
-    static auto stop_possible() noexcept -> std::true_type {
+    static auto stop_possible() noexcept -> std::true_type
+    {
       return {};
     }
 
-    auto operator==(const stopped_token&) const noexcept -> bool = default;
+    auto operator==(stopped_token const &) const noexcept -> bool = default;
   };
 
   template <class Token>
-  struct stopped_receiver_base {
+  struct stopped_receiver_base
+  {
     using receiver_concept = ex::receiver_t;
     Token stop_token_{};
   };
 
   template <class Token>
-  struct stopped_receiver_env {
-    const stopped_receiver_base<Token>* receiver_;
+  struct stopped_receiver_env
+  {
+    stopped_receiver_base<Token> const *receiver_;
 
     [[nodiscard]]
-    auto query(ex::get_stop_token_t) const noexcept -> Token {
+    auto query(ex::get_stop_token_t) const noexcept -> Token
+    {
       return receiver_->stop_token_;
     }
   };
 
   template <class Token>
-  struct stopped_receiver : stopped_receiver_base<Token> {
+  struct stopped_receiver : stopped_receiver_base<Token>
+  {
     stopped_receiver(Token token, bool expect_stop)
       : stopped_receiver_base<Token>{token}
-      , expect_stop_{expect_stop} {
-    }
+      , expect_stop_{expect_stop}
+    {}
 
     bool expect_stop_{false};
 
     template <class... Args>
-    void set_value(Args&&...) noexcept {
+    void set_value(Args &&...) noexcept
+    {
       CHECK(!expect_stop_);
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       CHECK(expect_stop_);
     }
 
     [[nodiscard]]
-    auto get_env() const noexcept -> stopped_receiver_env<Token> {
+    auto get_env() const noexcept -> stopped_receiver_env<Token>
+    {
       return {this};
     }
   };
@@ -431,79 +472,84 @@ namespace {
   template <class Token>
   stopped_receiver(Token, bool) -> stopped_receiver<Token>;
 
-  static_assert(ex::receiver_of<
-                stopped_receiver<ex::inplace_stop_token>,
-                ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>
-  >);
+  static_assert(
+    ex::receiver_of<stopped_receiver<ex::inplace_stop_token>,
+                    ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>>);
 
-  TEST_CASE("any_sender - does connect with stop token", "[types][any_sender]") {
-    using stoppable_sender = any_sender_of<ex::set_value_t(int), ex::set_stopped_t()>;
-    stoppable_sender sender = exec::when_any(ex::just(21));
+  TEST_CASE("any_sender - does connect with stop token", "[types][any_sender]")
+  {
+    using stoppable_sender         = any_sender_of<ex::set_value_t(int), ex::set_stopped_t()>;
+    stoppable_sender        sender = exec::when_any(ex::just(21));
     ex::inplace_stop_source stop_source{};
-    stopped_receiver receiver{stop_source.get_token(), true};
+    stopped_receiver        receiver{stop_source.get_token(), true};
     stop_source.request_stop();
     auto do_check = ex::connect(std::move(sender), std::move(receiver));
     // This CHECKS whether set_value is called
     ex::start(do_check);
   }
 
-  TEST_CASE("any_sender - does connect with an user-defined stop token", "[types][any_sender]") {
-    using stoppable_sender = any_sender_of<ex::set_value_t(int), ex::set_stopped_t()>;
+  TEST_CASE("any_sender - does connect with an user-defined stop token", "[types][any_sender]")
+  {
+    using stoppable_sender  = any_sender_of<ex::set_value_t(int), ex::set_stopped_t()>;
     stoppable_sender sender = exec::when_any(ex::just(21));
-    SECTION("stopped true") {
-      stopped_token token{true};
+    SECTION("stopped true")
+    {
+      stopped_token    token{true};
       stopped_receiver receiver{token, true};
-      auto do_check = ex::connect(std::move(sender), std::move(receiver));
+      auto             do_check = ex::connect(std::move(sender), std::move(receiver));
       // This CHECKS whether set_value is called
       ex::start(do_check);
     }
-    SECTION("stopped false") {
-      stopped_token token{false};
+    SECTION("stopped false")
+    {
+      stopped_token    token{false};
       stopped_receiver receiver{token, false};
-      auto do_check = ex::connect(std::move(sender), std::move(receiver));
+      auto             do_check = ex::connect(std::move(sender), std::move(receiver));
       // This CHECKS whether set_value is called
       ex::start(do_check);
     }
   }
 
-  TEST_CASE(
-    "any_sender - does connect with stop token if the get_stop_token query is registered with "
-    "ex::inplace_stop_token",
-    "[types][any_sender]") {
+  TEST_CASE("any_sender - does connect with stop token if the get_stop_token query is registered "
+            "with "
+            "ex::inplace_stop_token",
+            "[types][any_sender]")
+  {
     using Sigs = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
     using receiver_ref =
       exec::any_receiver_ref<Sigs, ex::get_stop_token.signature<ex::inplace_stop_token() noexcept>>;
-    using stoppable_sender = receiver_ref::any_sender<>;
-    stoppable_sender sender = exec::when_any(ex::just(21));
+    using stoppable_sender         = receiver_ref::any_sender<>;
+    stoppable_sender        sender = exec::when_any(ex::just(21));
     ex::inplace_stop_source stop_source{};
-    stopped_receiver receiver{stop_source.get_token(), true};
+    stopped_receiver        receiver{stop_source.get_token(), true};
     stop_source.request_stop();
     auto do_check = ex::connect(std::move(sender), std::move(receiver));
     // This CHECKS whether a set_stopped is called
     ex::start(do_check);
   }
 
-  TEST_CASE(
-    "any_sender - does connect with stop token if the ex::get_stop_token query is registered with "
-    "ex::never_stop_token",
-    "[types][any_sender]") {
+  TEST_CASE("any_sender - does connect with stop token if the ex::get_stop_token query is "
+            "registered with "
+            "ex::never_stop_token",
+            "[types][any_sender]")
+  {
     using Sigs = ex::completion_signatures<ex::set_value_t(int), ex::set_stopped_t()>;
     using receiver_ref =
       exec::any_receiver_ref<Sigs, ex::get_stop_token.signature<ex::never_stop_token() noexcept>>;
-    using unstoppable_sender = receiver_ref::any_sender<>;
-    unstoppable_sender sender = exec::when_any(ex::just(21));
+    using unstoppable_sender       = receiver_ref::any_sender<>;
+    unstoppable_sender      sender = exec::when_any(ex::just(21));
     ex::inplace_stop_source stop_source{};
-    stopped_receiver receiver{stop_source.get_token(), false};
+    stopped_receiver        receiver{stop_source.get_token(), false};
     stop_source.request_stop();
     auto do_check = ex::connect(std::move(sender), std::move(receiver));
     // This CHECKS whether a set_stopped is called
     ex::start(do_check);
   }
 
-  TEST_CASE(
-    "any_sender - get_completion_signatures is constrained with respect to stop-token"
-    "ex::receiver stop_token queries",
-    "[types][any_sender]") {
+  TEST_CASE("any_sender - get_completion_signatures is constrained with respect to stop-token"
+            "ex::receiver stop_token queries",
+            "[types][any_sender]")
+  {
     using Sigs = ex::completion_signatures<ex::set_value_t(), ex::set_stopped_t()>;
     using receiver_ref =
       exec::any_receiver_ref<Sigs, ex::get_stop_token.signature<ex::inplace_stop_token() noexcept>>;
@@ -527,10 +573,11 @@ namespace {
   template <auto... Queries>
   using my_scheduler = any_sender_of<>::any_scheduler<Queries...>;
 
-  TEST_CASE("any scheduler with inline_scheduler", "[types][any_sender]") {
+  TEST_CASE("any scheduler with inline_scheduler", "[types][any_sender]")
+  {
     static_assert(ex::scheduler<my_scheduler<>>);
     my_scheduler<> scheduler = ex::inline_scheduler();
-    my_scheduler<> copied = scheduler;
+    my_scheduler<> copied    = scheduler;
     CHECK(copied == scheduler);
 
     auto sndr = ex::schedule(scheduler);
@@ -544,12 +591,13 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE("queryable any_scheduler with inline_scheduler", "[types][any_sender]") {
-    using my_scheduler2 =
-      my_scheduler<ex::get_forward_progress_guarantee.signature<ex::forward_progress_guarantee() noexcept>>;
+  TEST_CASE("queryable any_scheduler with inline_scheduler", "[types][any_sender]")
+  {
+    using my_scheduler2 = my_scheduler<
+      ex::get_forward_progress_guarantee.signature<ex::forward_progress_guarantee() noexcept>>;
     static_assert(ex::scheduler<my_scheduler2>);
     my_scheduler2 scheduler = ex::inline_scheduler();
-    my_scheduler2 copied = scheduler;
+    my_scheduler2 copied    = scheduler;
     CHECK(copied == scheduler);
 
     auto sched = ex::schedule(scheduler);
@@ -558,66 +606,66 @@ namespace {
       ex::get_env(sched));
     CHECK(get_sched == scheduler);
 
-    CHECK(
-      ex::get_forward_progress_guarantee(scheduler)
-      == ex::get_forward_progress_guarantee(ex::inline_scheduler()));
+    CHECK(ex::get_forward_progress_guarantee(scheduler)
+          == ex::get_forward_progress_guarantee(ex::inline_scheduler()));
 
     bool called = false;
     ex::sync_wait(std::move(sched) | ex::then([&] { called = true; }));
     CHECK(called);
   }
 
-  TEST_CASE(
-    "any_scheduler adds ex::set_value_t() completion sig",
-    "[types][any_scheduler][any_sender]") {
+  TEST_CASE("any_scheduler adds ex::set_value_t() completion sig",
+            "[types][any_scheduler][any_sender]")
+  {
     using scheduler_t = any_sender_of<>::any_scheduler<>;
-    using schedule_t = decltype(ex::schedule(std::declval<scheduler_t>()));
-    CHECK(
-      std::is_same_v<ex::completion_signatures_of_t<schedule_t>, ex::completion_signatures<ex::set_value_t()>>);
+    using schedule_t  = decltype(ex::schedule(std::declval<scheduler_t>()));
+    CHECK(std::is_same_v<ex::completion_signatures_of_t<schedule_t>,
+                         ex::completion_signatures<ex::set_value_t()>>);
     CHECK(ex::scheduler<scheduler_t>);
   }
 
-  TEST_CASE(
-    "any_scheduler uniquely adds ex::set_value_t() completion sig",
-    "[types][any_scheduler][any_sender]") {
+  TEST_CASE("any_scheduler uniquely adds ex::set_value_t() completion sig",
+            "[types][any_scheduler][any_sender]")
+  {
     using scheduler_t = any_sender_of<ex::set_value_t()>::any_scheduler<>;
-    using schedule_t = decltype(ex::schedule(std::declval<scheduler_t>()));
-    CHECK(
-      std::is_same_v<ex::completion_signatures_of_t<schedule_t>, ex::completion_signatures<ex::set_value_t()>>);
+    using schedule_t  = decltype(ex::schedule(std::declval<scheduler_t>()));
+    CHECK(std::is_same_v<ex::completion_signatures_of_t<schedule_t>,
+                         ex::completion_signatures<ex::set_value_t()>>);
     CHECK(ex::scheduler<scheduler_t>);
   }
 
-  TEST_CASE(
-    "any_scheduler adds ex::set_value_t() completion sig (along with error)",
-    "[types][any_sender]") {
+  TEST_CASE("any_scheduler adds ex::set_value_t() completion sig (along with error)",
+            "[types][any_sender]")
+  {
     using scheduler_t = any_sender_of<ex::set_error_t(std::exception_ptr)>::any_scheduler<>;
-    using schedule_t = decltype(ex::schedule(std::declval<scheduler_t>()));
+    using schedule_t  = decltype(ex::schedule(std::declval<scheduler_t>()));
     CHECK(ex::sender_of<schedule_t, ex::set_value_t()>);
     CHECK(ex::sender_of<schedule_t, ex::set_error_t(std::exception_ptr)>);
   }
 
-  TEST_CASE(
-    "User-defined completion_scheduler<ex::set_value_t> is ignored",
-    "[types][any_scheduler][any_sender]") {
-    using not_scheduler_t = exec::any_receiver_ref<ex::completion_signatures<ex::set_value_t()>>::any_sender<
-      ex::get_completion_scheduler<ex::set_value_t>.signature<void()>
-    >::any_scheduler<>;
+  TEST_CASE("User-defined completion_scheduler<ex::set_value_t> is ignored",
+            "[types][any_scheduler][any_sender]")
+  {
+    using not_scheduler_t =
+      exec::any_receiver_ref<ex::completion_signatures<ex::set_value_t()>>::any_sender<
+        ex::get_completion_scheduler<ex::set_value_t>.signature<void()>>::any_scheduler<>;
     CHECK(ex::scheduler<not_scheduler_t>);
   }
 
   template <auto... Queries>
   using stoppable_scheduler = any_sender_of<ex::set_stopped_t()>::any_scheduler<Queries...>;
 
-  TEST_CASE("any scheduler with static_thread_pool", "[types][any_sender]") {
+  TEST_CASE("any scheduler with static_thread_pool", "[types][any_sender]")
+  {
     exec::static_thread_pool pool(1);
-    stoppable_scheduler<> scheduler = pool.get_scheduler();
-    auto copied = scheduler;
+    stoppable_scheduler<>    scheduler = pool.get_scheduler();
+    auto                     copied    = scheduler;
     CHECK(copied == scheduler);
 
     auto sched = ex::schedule(scheduler);
     static_assert(ex::sender<decltype(sched)>);
-    std::same_as<stoppable_scheduler<>> auto get_sched = ex::get_completion_scheduler<ex::set_value_t>(
-      ex::get_env(sched));
+    std::same_as<stoppable_scheduler<>> auto get_sched =
+      ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(sched));
     CHECK(get_sched == scheduler);
 
     bool called = false;
@@ -625,13 +673,14 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE("queryable any_scheduler with static_thread_pool", "[types][any_sender]") {
-    using my_scheduler = stoppable_scheduler<ex::get_forward_progress_guarantee
-                                               .signature<ex::forward_progress_guarantee() noexcept>>;
+  TEST_CASE("queryable any_scheduler with static_thread_pool", "[types][any_sender]")
+  {
+    using my_scheduler = stoppable_scheduler<
+      ex::get_forward_progress_guarantee.signature<ex::forward_progress_guarantee() noexcept>>;
 
     exec::static_thread_pool pool(1);
-    my_scheduler scheduler = pool.get_scheduler();
-    auto copied = scheduler;
+    my_scheduler             scheduler = pool.get_scheduler();
+    auto                     copied    = scheduler;
     CHECK(copied == scheduler);
 
     auto sched = ex::schedule(scheduler);
@@ -640,20 +689,20 @@ namespace {
       ex::get_env(sched));
     CHECK(get_sched == scheduler);
 
-    CHECK(
-      ex::get_forward_progress_guarantee(scheduler)
-      == ex::get_forward_progress_guarantee(pool.get_scheduler()));
+    CHECK(ex::get_forward_progress_guarantee(scheduler)
+          == ex::get_forward_progress_guarantee(pool.get_scheduler()));
 
     bool called = false;
     ex::sync_wait(std::move(sched) | ex::then([&] { called = true; }));
     CHECK(called);
   }
 
-  TEST_CASE("Scheduler with error handling and set_stopped", "[types][any_scheduler][any_sender]") {
-    using receiver_ref =
-      exec::any_receiver_ref<ex::completion_signatures<ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>>;
-    using sender_t = receiver_ref::any_sender<>;
-    using scheduler_t = sender_t::any_scheduler<>;
+  TEST_CASE("Scheduler with error handling and set_stopped", "[types][any_scheduler][any_sender]")
+  {
+    using receiver_ref = exec::any_receiver_ref<
+      ex::completion_signatures<ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>>;
+    using sender_t        = receiver_ref::any_sender<>;
+    using scheduler_t     = sender_t::any_scheduler<>;
     scheduler_t scheduler = ex::inline_scheduler();
     {
       auto op = ex::connect(ex::schedule(scheduler), expect_void_receiver{});
@@ -671,14 +720,15 @@ namespace {
     }
   }
 
-  TEST_CASE("Schedule Sender lifetime", "[types][any_scheduler][any_sender]") {
-    using receiver_ref =
-      exec::any_receiver_ref<ex::completion_signatures<ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>>;
-    using sender_t = receiver_ref::any_sender<>;
-    using scheduler_t = sender_t::any_scheduler<>;
+  TEST_CASE("Schedule Sender lifetime", "[types][any_scheduler][any_sender]")
+  {
+    using receiver_ref = exec::any_receiver_ref<
+      ex::completion_signatures<ex::set_stopped_t(), ex::set_error_t(std::exception_ptr)>>;
+    using sender_t        = receiver_ref::any_sender<>;
+    using scheduler_t     = sender_t::any_scheduler<>;
     scheduler_t scheduler = ex::inline_scheduler();
-    auto sched = ex::schedule(scheduler);
-    scheduler = stopped_scheduler();
+    auto        sched     = ex::schedule(scheduler);
+    scheduler             = stopped_scheduler();
     {
       auto op = ex::connect(ex::schedule(scheduler), expect_stopped_receiver{});
       ex::start(op);
@@ -690,76 +740,88 @@ namespace {
   }
 
   // A scheduler that counts how many instances are extant.
-  struct counting_scheduler {
+  struct counting_scheduler
+  {
     static int count;
 
-    counting_scheduler() noexcept {
+    counting_scheduler() noexcept
+    {
       ++count;
     }
 
-    counting_scheduler(const counting_scheduler&) noexcept {
+    counting_scheduler(counting_scheduler const &) noexcept
+    {
       ++count;
     }
 
-    counting_scheduler(counting_scheduler&&) noexcept {
+    counting_scheduler(counting_scheduler &&) noexcept
+    {
       ++count;
     }
 
-    ~counting_scheduler() {
+    ~counting_scheduler()
+    {
       --count;
     }
 
-    auto operator==(const counting_scheduler&) const noexcept -> bool = default;
+    auto operator==(counting_scheduler const &) const noexcept -> bool = default;
 
    private:
     template <class R>
-    struct operation : immovable {
+    struct operation : immovable
+    {
       R recv_;
 
-      void start() & noexcept {
-        ex::set_value(static_cast<R&&>(recv_));
+      void start() & noexcept
+      {
+        ex::set_value(static_cast<R &&>(recv_));
       }
     };
 
-    struct sender {
-      using sender_concept = ex::sender_t;
+    struct sender
+    {
+      using sender_concept        = ex::sender_t;
       using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
       template <ex::receiver R>
-      auto connect(R r) const -> operation<R> {
-        return {{}, static_cast<R&&>(r)};
+      auto connect(R r) const -> operation<R>
+      {
+        return {{}, static_cast<R &&>(r)};
       }
 
       [[nodiscard]]
-      auto query(ex::get_completion_scheduler_t<ex::set_value_t>) const noexcept
-        -> counting_scheduler {
+      auto
+      query(ex::get_completion_scheduler_t<ex::set_value_t>) const noexcept -> counting_scheduler
+      {
         return {};
       }
 
       [[nodiscard]]
-      auto get_env() const noexcept -> const sender& {
+      auto get_env() const noexcept -> sender const &
+      {
         return *this;
       }
     };
 
    public:
     [[nodiscard]]
-    auto schedule() const noexcept -> sender {
+    auto schedule() const noexcept -> sender
+    {
       return {};
     }
   };
 
   int counting_scheduler::count = 0;
 
-  TEST_CASE(
-    "check that any_scheduler cleans up all resources",
-    "[types][any_scheduler][any_sender]") {
+  TEST_CASE("check that any_scheduler cleans up all resources",
+            "[types][any_scheduler][any_sender]")
+  {
     using receiver_ref = exec::any_receiver_ref<ex::completion_signatures<ex::set_value_t()>>;
-    using sender_t = receiver_ref::any_sender<>;
-    using scheduler_t = sender_t::any_scheduler<>;
+    using sender_t     = receiver_ref::any_sender<>;
+    using scheduler_t  = sender_t::any_scheduler<>;
     {
       scheduler_t scheduler = ex::inline_scheduler{};
-      scheduler = counting_scheduler{};
+      scheduler             = counting_scheduler{};
       {
         auto op = ex::connect(ex::schedule(scheduler), expect_value_receiver<>{});
         ex::start(op);
@@ -768,6 +830,6 @@ namespace {
     CHECK(counting_scheduler::count == 0);
   }
 
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/exec/test_at_coroutine_exit.cpp b/test/exec/test_at_coroutine_exit.cpp
index d14f9847b..25e44141a 100644
--- a/test/exec/test_at_coroutine_exit.cpp
+++ b/test/exec/test_at_coroutine_exit.cpp
@@ -28,174 +28,228 @@
 using namespace exec;
 using STDEXEC::sync_wait;
 
-namespace {
-  auto stop() {
+namespace
+{
+  auto stop()
+  {
     static stopped_scheduler scheduler{};
-    auto stop = STDEXEC::schedule(scheduler);
+    auto                     stop = STDEXEC::schedule(scheduler);
     return stop;
   }
 
-  auto test_one_cleanup_action(int& result) -> task<void> {
+  auto test_one_cleanup_action(int& result) -> task<void>
+  {
     ++result;
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= 2;
-      co_return;
-    });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= 2;
+        co_return;
+      });
     ++result;
   }
 
-  auto test_two_cleanup_actions(int& result) -> task<void> {
+  auto test_two_cleanup_actions(int& result) -> task<void>
+  {
     ++result;
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= 2;
-      co_return;
-    });
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= result;
-      co_return;
-    });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= 2;
+        co_return;
+      });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= result;
+        co_return;
+      });
     ++result;
   }
 
-  auto test_on_stopped_two_cleanup_actions_with_stop(int& result) -> task<void> {
+  auto test_on_stopped_two_cleanup_actions_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_stopped([&result]() -> task<void> {
-      result *= 2;
-      co_return;
-    });
-    co_await on_coroutine_stopped([&result]() -> task<void> {
-      result *= result;
-      co_return;
-    });
+    co_await on_coroutine_stopped(
+      [&result]() -> task<void>
+      {
+        result *= 2;
+        co_return;
+      });
+    co_await on_coroutine_stopped(
+      [&result]() -> task<void>
+      {
+        result *= result;
+        co_return;
+      });
     ++result;
     co_await stop();
   }
 
-  auto test_one_cleanup_action_with_stop(int& result) -> task<void> {
+  auto test_one_cleanup_action_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= 2;
-      co_return;
-    });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= 2;
+        co_return;
+      });
     co_await stop();
     ++result;
   }
 
-  auto test_on_succeeded_one_cleanup_action(int& result) -> task<void> {
+  auto test_on_succeeded_one_cleanup_action(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_succeeded([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_succeeded(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     ++result;
   }
 
-  auto test_on_succeeded_one_cleanup_action_with_stop(int& result) -> task<void> {
+  auto test_on_succeeded_one_cleanup_action_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_succeeded([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_succeeded(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     co_await stop();
     ++result;
   }
 
-  auto test_on_succeeded_one_cleanup_action_with_error(int& result) -> task<void> {
+  auto test_on_succeeded_one_cleanup_action_with_error(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_succeeded([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_succeeded(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     throw 42;
     ++result;
   }
 
-  auto test_on_stopped_one_cleanup_action(int& result) -> task<void> {
+  auto test_on_stopped_one_cleanup_action(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_stopped([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_stopped(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     ++result;
   }
 
-  auto test_on_stopped_one_cleanup_action_with_stop(int& result) -> task<void> {
+  auto test_on_stopped_one_cleanup_action_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_stopped([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_stopped(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     co_await stop();
     ++result;
   }
 
-  auto test_on_stopped_one_cleanup_action_with_error(int& result) -> task<void> {
+  auto test_on_stopped_one_cleanup_action_with_error(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_stopped([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_stopped(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     throw 42;
     ++result;
   }
 
-  auto test_on_failed_one_cleanup_action(int& result) -> task<void> {
+  auto test_on_failed_one_cleanup_action(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_failed([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_failed(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     ++result;
   }
 
-  auto test_on_failed_one_cleanup_action_with_stop(int& result) -> task<void> {
+  auto test_on_failed_one_cleanup_action_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_failed([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_failed(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     co_await stop();
     ++result;
   }
 
-  auto test_on_failed_one_cleanup_action_with_error(int& result) -> task<void> {
+  auto test_on_failed_one_cleanup_action_with_error(int& result) -> task<void>
+  {
     ++result;
-    co_await on_coroutine_failed([&result]() -> task<void> {
-      result *= 3;
-      co_return;
-    });
+    co_await on_coroutine_failed(
+      [&result]() -> task<void>
+      {
+        result *= 3;
+        co_return;
+      });
     throw 42;
     ++result;
   }
 
-  auto test_two_cleanup_actions_with_stop(int& result) -> task<void> {
+  auto test_two_cleanup_actions_with_stop(int& result) -> task<void>
+  {
     ++result;
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= 2;
-      co_return;
-    });
-    co_await at_coroutine_exit([&result]() -> task<void> {
-      result *= result;
-      co_return;
-    });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= 2;
+        co_return;
+      });
+    co_await at_coroutine_exit(
+      [&result]() -> task<void>
+      {
+        result *= result;
+        co_return;
+      });
     co_await stop();
     ++result;
   }
 
-  auto test_sender_cleanup_action(int& result) -> task<void> {
+  auto test_sender_cleanup_action(int& result) -> task<void>
+  {
     co_await at_coroutine_exit(
       [&result] { return STDEXEC::just() | STDEXEC::then([&result] { ++result; }); });
   }
 
-  auto test_stateful_cleanup_action(int& result, int arg) -> task<void> {
-    co_await at_coroutine_exit([arg, &result] {
-      return STDEXEC::just() | STDEXEC::then([arg, &result] { result += arg; });
-    });
+  auto test_stateful_cleanup_action(int& result, int arg) -> task<void>
+  {
+    co_await at_coroutine_exit(
+      [arg, &result]
+      { return STDEXEC::just() | STDEXEC::then([arg, &result] { result += arg; }); });
   }
 
-  auto test_mutable_stateful_cleanup_action(int& result) -> task<void> {
+  auto test_mutable_stateful_cleanup_action(int& result) -> task<void>
+  {
     auto&& [i] = co_await at_coroutine_exit(
-      [&result](int&& i) -> task<void> {
+      [&result](int&& i) -> task<void>
+      {
         result += i;
         co_return;
       },
@@ -204,9 +258,11 @@ namespace {
     i *= i;
   }
 
-  auto test_on_succeeded_mutable_stateful_cleanup_action(int& result) -> task<void> {
+  auto test_on_succeeded_mutable_stateful_cleanup_action(int& result) -> task<void>
+  {
     auto&& [i] = co_await on_coroutine_succeeded(
-      [&result](int&& i) -> task<void> {
+      [&result](int&& i) -> task<void>
+      {
         result += i;
         co_return;
       },
@@ -215,191 +271,228 @@ namespace {
     i *= i;
   }
 
-  auto with_continuation(int& result, task<void> next) -> task<void> {
+  auto with_continuation(int& result, task<void> next) -> task<void>
+  {
     co_await std::move(next);
     result *= 3;
   }
 
 #  ifdef REQUIRE_TERMINATE
 
-  void test_cancel_in_cleanup_action_causes_death(int&) {
-    task<void> t = []() -> task<void> {
+  void test_cancel_in_cleanup_action_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
       co_await at_coroutine_exit([]() -> task<void> { co_await stop(); });
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-  void test_cancel_during_cancellation_unwind_causes_death(int&) {
-    task<void> t = []() -> task<void> {
-      co_await at_coroutine_exit([]() -> task<void> {
-        co_await stop(); // BOOM
-      });
+  void test_cancel_during_cancellation_unwind_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
+      co_await at_coroutine_exit(
+        []() -> task<void>
+        {
+          co_await stop();  // BOOM
+        });
       co_await stop();
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-  void test_throw_in_cleanup_action_causes_death(int&) {
-    task<void> t = []() -> task<void> {
+  void test_throw_in_cleanup_action_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
       co_await at_coroutine_exit([]() -> task<void> { throw 42; });
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-  void test_throw_in_cleanup_action_during_exception_unwind_causes_death(int&) {
-    task<void> t = []() -> task<void> {
+  void test_throw_in_cleanup_action_during_exception_unwind_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
       co_await at_coroutine_exit([]() -> task<void> { throw 42; });
       throw 42;
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-  void test_cancel_in_cleanup_action_during_exception_unwind_causes_death(int&) {
-    task<void> t = []() -> task<void> {
+  void test_cancel_in_cleanup_action_during_exception_unwind_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
       co_await at_coroutine_exit([]() -> task<void> { co_await stop(); });
       throw 42;
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-  void test_throw_in_cleanup_action_during_cancellation_unwind_causes_death(int&) {
-    task<void> t = []() -> task<void> {
+  void test_throw_in_cleanup_action_during_cancellation_unwind_causes_death(int&)
+  {
+    task<void> t = []() -> task<void>
+    {
       co_await at_coroutine_exit([]() -> task<void> { throw 42; });
       co_await stop();
     }();
     REQUIRE_TERMINATE([&] { sync_wait(std::move(t)); });
   }
 
-#  endif // REQUIRE_TERMINATE
+#  endif  // REQUIRE_TERMINATE
 
-  TEST_CASE("OneCleanupAction", "[task][at_coroutine_exit]") {
+  TEST_CASE("OneCleanupAction", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_one_cleanup_action(result));
     REQUIRE(result == 4);
   }
 
-  TEST_CASE("TwoCleanupActions", "[task][at_coroutine_exit]") {
+  TEST_CASE("TwoCleanupActions", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_two_cleanup_actions(result));
     REQUIRE(result == 8);
   }
 
-  TEST_CASE("OnStoppedTwoCleanupActions", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnStoppedTwoCleanupActions", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_stopped_two_cleanup_actions_with_stop(result));
     REQUIRE(result == 8);
   }
 
-  TEST_CASE("OneCleanupActionWithContinuation", "[task][at_coroutine_exit]") {
+  TEST_CASE("OneCleanupActionWithContinuation", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(with_continuation(result, test_one_cleanup_action(result)));
     REQUIRE(result == 12);
   }
 
-  TEST_CASE("TwoCleanupActionsWithContinuation", "[task][at_coroutine_exit]") {
+  TEST_CASE("TwoCleanupActionsWithContinuation", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(with_continuation(result, test_two_cleanup_actions(result)));
     REQUIRE(result == 24);
   }
 
-  TEST_CASE("CleanupActionWithSender", "[task][at_coroutine_exit]") {
+  TEST_CASE("CleanupActionWithSender", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_sender_cleanup_action(result));
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("OneCleanupActionWithStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("OneCleanupActionWithStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_one_cleanup_action_with_stop(result));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("OnSucceededOneCleanupAction", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnSucceededOneCleanupAction", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_succeeded_one_cleanup_action(result));
     REQUIRE(result == 6);
   }
 
-  TEST_CASE("OnSucceededOneCleanupActionWithStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnSucceededOneCleanupActionWithStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_succeeded_one_cleanup_action_with_stop(result));
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("OnSucceededOneCleanupActionWithError", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnSucceededOneCleanupActionWithError", "[task][at_coroutine_exit]")
+  {
     int result = 0;
-    CHECK_THROWS_AS(
-      STDEXEC::sync_wait(test_on_succeeded_one_cleanup_action_with_error(result)), int);
+    CHECK_THROWS_AS(STDEXEC::sync_wait(test_on_succeeded_one_cleanup_action_with_error(result)),
+                    int);
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("OnStoppedOneCleanupActionSuccess", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnStoppedOneCleanupActionSuccess", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_stopped_one_cleanup_action(result));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("OnStoppedOneCleanupActionWithStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnStoppedOneCleanupActionWithStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_stopped_one_cleanup_action_with_stop(result));
     REQUIRE(result == 3);
   }
 
-  TEST_CASE("OnStoppedOneCleanupActionWithError", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnStoppedOneCleanupActionWithError", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     CHECK_THROWS_AS(STDEXEC::sync_wait(test_on_stopped_one_cleanup_action_with_error(result)), int);
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("OnFailedOneCleanupActionSuccess", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnFailedOneCleanupActionSuccess", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_failed_one_cleanup_action(result));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("OnFailedOneCleanupActionWithStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnFailedOneCleanupActionWithStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_failed_one_cleanup_action_with_stop(result));
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("OnFailedOneCleanupActionWithError", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnFailedOneCleanupActionWithError", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     CHECK_THROWS_AS(STDEXEC::sync_wait(test_on_failed_one_cleanup_action_with_error(result)), int);
     REQUIRE(result == 3);
   }
 
-  TEST_CASE("TwoCleanupActionsWithStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("TwoCleanupActionsWithStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_two_cleanup_actions_with_stop(result));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("OneCleanupActionWithContinuationAndStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("OneCleanupActionWithContinuationAndStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(with_continuation(result, test_one_cleanup_action_with_stop(result)));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("TwoCleanupActionsWithContinuationAndStop", "[task][at_coroutine_exit]") {
+  TEST_CASE("TwoCleanupActionsWithContinuationAndStop", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(with_continuation(result, test_two_cleanup_actions_with_stop(result)));
     REQUIRE(result == 2);
   }
 
-  TEST_CASE("CleanupActionWithStatefulSender", "[task][at_coroutine_exit]") {
+  TEST_CASE("CleanupActionWithStatefulSender", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_stateful_cleanup_action(result, 42));
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("CleanupActionWithMutableStateful", "[task][at_coroutine_exit]") {
+  TEST_CASE("CleanupActionWithMutableStateful", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_mutable_stateful_cleanup_action(result));
     REQUIRE(result == 10);
   }
 
-  TEST_CASE("OnSuccessCleanupActionWithMutableStateful", "[task][at_coroutine_exit]") {
+  TEST_CASE("OnSuccessCleanupActionWithMutableStateful", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     STDEXEC::sync_wait(test_on_succeeded_mutable_stateful_cleanup_action(result));
     REQUIRE(result == 10);
@@ -407,44 +500,45 @@ namespace {
 
 #  ifdef REQUIRE_TERMINATE
 
-  TEST_CASE("CancelInCleanupActionCallsTerminate", "[task][at_coroutine_exit]") {
+  TEST_CASE("CancelInCleanupActionCallsTerminate", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_cancel_in_cleanup_action_causes_death(result);
   }
 
-  TEST_CASE("CancelDuringCancellationUnwindCallsTerminate", "[task][at_coroutine_exit]") {
+  TEST_CASE("CancelDuringCancellationUnwindCallsTerminate", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_cancel_during_cancellation_unwind_causes_death(result);
   }
 
-  TEST_CASE("ThrowInCleanupActionCallsTerminate", "[task][at_coroutine_exit]") {
+  TEST_CASE("ThrowInCleanupActionCallsTerminate", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_throw_in_cleanup_action_causes_death(result);
   }
 
-  TEST_CASE(
-    "ThrowInCleanupActionDuringExceptionUnwindCallsTerminate",
-    "[task][at_coroutine_exit]") {
+  TEST_CASE("ThrowInCleanupActionDuringExceptionUnwindCallsTerminate", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_throw_in_cleanup_action_during_exception_unwind_causes_death(result);
   }
 
-  TEST_CASE(
-    "CancelInCleanupActionDuringExceptionUnwindCallsTerminate",
-    "[task][at_coroutine_exit]") {
+  TEST_CASE("CancelInCleanupActionDuringExceptionUnwindCallsTerminate", "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_cancel_in_cleanup_action_during_exception_unwind_causes_death(result);
   }
 
-  TEST_CASE(
-    "ThrowInCleanupActionDuringCancellationUnwindCallsTerminate",
-    "[task][at_coroutine_exit]") {
+  TEST_CASE("ThrowInCleanupActionDuringCancellationUnwindCallsTerminate",
+            "[task][at_coroutine_exit]")
+  {
     int result = 0;
     test_throw_in_cleanup_action_during_cancellation_unwind_causes_death(result);
   }
 
-#  endif // REQUIRE_TERMINATE
+#  endif  // REQUIRE_TERMINATE
 
-} // unnamed namespace
+}  // unnamed namespace
 
-#endif // !STDEXEC_NO_STD_COROUTINES() && !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_COROUTINES() && !STDEXEC_NO_STD_EXCEPTIONS()
diff --git a/test/exec/test_bwos_lifo_queue.cpp b/test/exec/test_bwos_lifo_queue.cpp
index cb80e5b67..03691fafb 100644
--- a/test/exec/test_bwos_lifo_queue.cpp
+++ b/test/exec/test_bwos_lifo_queue.cpp
@@ -18,45 +18,54 @@
 
 #include <catch2/catch.hpp>
 
-TEST_CASE("exec::bwos::lifo_queue - ", "[bwos]") {
+TEST_CASE("exec::bwos::lifo_queue - ", "[bwos]")
+{
   exec::bwos::lifo_queue<int*> queue(8, 2);
-  int x = 1;
-  int y = 2;
-  SECTION("Observers") {
+  int                          x = 1;
+  int                          y = 2;
+  SECTION("Observers")
+  {
     CHECK(queue.block_size() == 2);
     CHECK(queue.num_blocks() == 8);
   }
-  SECTION("Empty Get") {
+  SECTION("Empty Get")
+  {
     CHECK(queue.pop_back() == nullptr);
   }
-  SECTION("Empty Steal") {
+  SECTION("Empty Steal")
+  {
     CHECK(queue.steal_front() == nullptr);
   }
-  SECTION("Put one, get one") {
+  SECTION("Put one, get one")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.pop_back() == &x);
     CHECK(queue.pop_back() == nullptr);
   }
-  SECTION("Put one, steal none") {
+  SECTION("Put one, steal none")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.steal_front() == nullptr);
     CHECK(queue.pop_back() == &x);
   }
-  SECTION("Put one, get one, put one, get one") {
+  SECTION("Put one, get one, put one, get one")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.pop_back() == &x);
     CHECK(queue.push_back(&y));
     CHECK(queue.pop_back() == &y);
     CHECK(queue.pop_back() == nullptr);
   }
-  SECTION("Put two, get two") {
+  SECTION("Put two, get two")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.push_back(&y));
     CHECK(queue.pop_back() == &y);
     CHECK(queue.pop_back() == &x);
     CHECK(queue.pop_back() == nullptr);
   }
-  SECTION("Put three, Steal two") {
+  SECTION("Put three, Steal two")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.push_back(&y));
     CHECK(queue.push_back(&x));
@@ -66,7 +75,8 @@ TEST_CASE("exec::bwos::lifo_queue - ", "[bwos]") {
     CHECK(queue.pop_back() == &x);
     CHECK(queue.pop_back() == nullptr);
   }
-  SECTION("Put 4, Steal 1, Get 3") {
+  SECTION("Put 4, Steal 1, Get 3")
+  {
     CHECK(queue.push_back(&x));
     CHECK(queue.push_back(&y));
     CHECK(queue.push_back(&x));
diff --git a/test/exec/test_completion_signatures.cpp b/test/exec/test_completion_signatures.cpp
index 195212e93..cce13641c 100644
--- a/test/exec/test_completion_signatures.cpp
+++ b/test/exec/test_completion_signatures.cpp
@@ -39,14 +39,17 @@ using STDEXEC::set_value;
 using STDEXEC::set_value_t;
 // NOLINTEND(misc-unused-using-decls)
 
-namespace {
-  TEST_CASE("", "[utilities][completion_signatures]") {
+namespace
+{
+  TEST_CASE("", "[utilities][completion_signatures]")
+  {
     STATIC_REQUIRE(completion_signatures{} == completion_signatures{});
     STATIC_REQUIRE_FALSE(completion_signatures{} != completion_signatures{});
   }
 
   // Additional tests for completion_signatures
-  TEST_CASE("completion_signatures_basic", "[utilities][completion_signatures]") {
+  TEST_CASE("completion_signatures_basic", "[utilities][completion_signatures]")
+  {
     constexpr auto cs_empty = completion_signatures<>{};
     constexpr auto cs_value = completion_signatures<set_value_t(int)>{};
     constexpr auto cs_error = completion_signatures<set_error_t(float)>{};
@@ -74,9 +77,8 @@ namespace {
     STATIC_REQUIRE_FALSE(cs_value == cs_error);
     STATIC_REQUIRE(cs_empty == cs_empty);
     STATIC_REQUIRE(cs_all == cs_all);
-    STATIC_REQUIRE(
-      completion_signatures<set_value_t(int), set_error_t(float), set_value_t(int)>{}
-      == completion_signatures<set_error_t(float), set_value_t(int)>{});
+    STATIC_REQUIRE(completion_signatures<set_value_t(int), set_error_t(float), set_value_t(int)>{}
+                   == completion_signatures<set_error_t(float), set_value_t(int)>{});
 
     // Test operator!=
     STATIC_REQUIRE(cs_value != cs_error);
@@ -100,7 +102,8 @@ namespace {
   }
 
   // Test select
-  TEST_CASE("completion_signatures_select", "[utilities][completion_signatures]") {
+  TEST_CASE("completion_signatures_select", "[utilities][completion_signatures]")
+  {
     constexpr auto cs =
       completion_signatures<set_value_t(int), set_error_t(float), set_stopped_t()>{};
 
@@ -121,15 +124,18 @@ namespace {
   }
 
   // Test filter
-  struct filter_value_only {
+  struct filter_value_only
+  {
     template <class Sig>
-    constexpr bool operator()(Sig*) const noexcept {
+    constexpr bool operator()(Sig*) const noexcept
+    {
       return STDEXEC::__detail::__tag_of_sig_t<Sig>::__disposition
           == STDEXEC::__disposition::__value;
     }
   };
 
-  TEST_CASE("completion_signatures_filter", "[utilities][completion_signatures]") {
+  TEST_CASE("completion_signatures_filter", "[utilities][completion_signatures]")
+  {
     constexpr auto cs =
       completion_signatures<set_value_t(int), set_error_t(float), set_stopped_t()>{};
     constexpr auto filtered = cs.__filter(filter_value_only{});
@@ -138,17 +144,20 @@ namespace {
   }
 
   // Test apply
-  struct count_signatures {
+  struct count_signatures
+  {
     template <class... Sigs>
-    constexpr int operator()(Sigs*...) const noexcept {
+    constexpr int operator()(Sigs*...) const noexcept
+    {
       return sizeof...(Sigs);
     }
   };
 
-  TEST_CASE("completion_signatures_apply", "[utilities][completion_signatures]") {
+  TEST_CASE("completion_signatures_apply", "[utilities][completion_signatures]")
+  {
     constexpr auto cs =
       completion_signatures<set_value_t(int), set_error_t(float), set_stopped_t()>{};
     constexpr int count = cs.__apply(count_signatures{});
     STATIC_REQUIRE(count == 3);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_cpo_ensure_started.cpp b/test/exec/test_cpo_ensure_started.cpp
index e06836586..6b37d7cce 100644
--- a/test/exec/test_cpo_ensure_started.cpp
+++ b/test/exec/test_cpo_ensure_started.cpp
@@ -21,24 +21,27 @@
 
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("ensure_started is customizable", "[cpo][cpo_ensure_started]") {
-    SECTION("by completion scheduler domain") {
+  TEST_CASE("ensure_started is customizable", "[cpo][cpo_ensure_started]")
+  {
+    SECTION("by completion scheduler domain")
+    {
       cpo_test_scheduler_t<exec::ensure_started_t>::sender_t snd{};
 
       {
-        constexpr scope_t scope = decltype(ex::connect(
-          snd | exec::ensure_started(), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(snd | exec::ensure_started(),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
 
       {
         void(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(snd)));
-        constexpr scope_t scope =
-          decltype(ex::connect(exec::ensure_started(snd), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(exec::ensure_started(snd),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_cpo_split.cpp b/test/exec/test_cpo_split.cpp
index 1bea4cb7c..e0debc570 100644
--- a/test/exec/test_cpo_split.cpp
+++ b/test/exec/test_cpo_split.cpp
@@ -21,24 +21,27 @@
 
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("split is customizable", "[cpo][cpo_split]") {
-    SECTION("by completion scheduler domain") {
+  TEST_CASE("split is customizable", "[cpo][cpo_split]")
+  {
+    SECTION("by completion scheduler domain")
+    {
       cpo_test_scheduler_t<exec::split_t>::sender_t snd{};
 
       {
-        constexpr scope_t scope =
-          decltype(ex::connect(exec::split(snd), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(exec::split(snd),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
 
       {
         void(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(snd)));
-        constexpr scope_t scope =
-          decltype(ex::connect(snd | exec::split(), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(snd | exec::split(),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_create.cpp b/test/exec/test_create.cpp
index 811355d01..16ce5da49 100644
--- a/test/exec/test_create.cpp
+++ b/test/exec/test_create.cpp
@@ -25,75 +25,97 @@
 using namespace std;
 namespace ex = STDEXEC;
 
-namespace {
-  struct immovable {
-    immovable() = default;
+namespace
+{
+  struct immovable
+  {
+    immovable()            = default;
     immovable(immovable&&) = delete;
   };
 
-  struct create_test_fixture {
+  struct create_test_fixture
+  {
     exec::static_thread_pool pool_{2};
-    exec::async_scope scope_;
+    exec::async_scope        scope_;
 
-    ~create_test_fixture() {
+    ~create_test_fixture()
+    {
       STDEXEC::sync_wait(scope_.on_empty());
     }
 
-    void anIntAPI(int a, int b, void* context, void (*completed)(void* context, int result)) {
+    void anIntAPI(int a, int b, void* context, void (*completed)(void* context, int result))
+    {
       // Execute some work asynchronously on some other thread. When its
       // work is finished, pass the result to the callback.
-      scope_.spawn(ex::starts_on(pool_.get_scheduler(), ex::then(ex::just(), [=]() noexcept {
-                                   auto result = a + b;
-                                   completed(context, result);
-                                 })));
+      scope_.spawn(ex::starts_on(pool_.get_scheduler(),
+                                 ex::then(ex::just(),
+                                          [=]() noexcept
+                                          {
+                                            auto result = a + b;
+                                            completed(context, result);
+                                          })));
     }
 
-    void aVoidAPI(void* context, void (*completed)(void* context)) {
+    void aVoidAPI(void* context, void (*completed)(void* context))
+    {
       // Execute some work asynchronously on some other thread. When its
       // work is finished, pass the result to the callback.
-      scope_.spawn(ex::starts_on(pool_.get_scheduler(), ex::then(ex::just(), [=]() noexcept {
-                                   completed(context);
-                                 })));
+      scope_.spawn(ex::starts_on(pool_.get_scheduler(),
+                                 ex::then(ex::just(), [=]() noexcept { completed(context); })));
     }
   };
 
-  TEST_CASE_METHOD(
-    create_test_fixture,
-    "wrap an async API that computes a result",
-    "[detail][create]") {
-    auto snd = [this](int a, int b) {
-      return exec::create<ex::set_value_t(int)>([a, b, this]<class Context>(Context& ctx) noexcept {
-        anIntAPI(a, b, &ctx, [](void* pv, int result) {
-          ex::set_value(std::move(static_cast<Context*>(pv)->receiver), static_cast<int>(result));
+  TEST_CASE_METHOD(create_test_fixture,
+                   "wrap an async API that computes a result",
+                   "[detail][create]")
+  {
+    auto snd = [this](int a, int b)
+    {
+      return exec::create<ex::set_value_t(int)>(
+        [a, b, this]<class Context>(Context& ctx) noexcept
+        {
+          anIntAPI(a,
+                   b,
+                   &ctx,
+                   [](void* pv, int result)
+                   {
+                     ex::set_value(std::move(static_cast<Context*>(pv)->receiver),
+                                   static_cast<int>(result));
+                   });
         });
-      });
     }(1, 2);
 
 #if STDEXEC_NO_STD_EXCEPTIONS()
     auto [res] = STDEXEC::sync_wait(std::move(snd)).value();
     CHECK(res == 3);
 #else
-    REQUIRE_NOTHROW([&] {
-      auto [res] = STDEXEC::sync_wait(std::move(snd)).value();
-      CHECK(res == 3);
-    }());
+    REQUIRE_NOTHROW(
+      [&]
+      {
+        auto [res] = STDEXEC::sync_wait(std::move(snd)).value();
+        CHECK(res == 3);
+      }());
 #endif
   }
 
-  TEST_CASE_METHOD(
-    create_test_fixture,
-    "wrap an async API that doesn't compute a result",
-    "[detail][create]") {
+  TEST_CASE_METHOD(create_test_fixture,
+                   "wrap an async API that doesn't compute a result",
+                   "[detail][create]")
+  {
     bool called = false;
-    auto snd = [&called, this]() {
+    auto snd    = [&called, this]()
+    {
       using completions = ex::completion_signatures<ex::set_value_t()>;
       return exec::create<completions>(
-        [this]<class Context>(Context& ctx) noexcept {
-          aVoidAPI(&ctx, [](void* pv) {
-            Context& ctx = *static_cast<Context*>(pv);
-            *std::get<0>(ctx.args) = true;
-            ex::set_value(std::move(ctx.receiver));
-          });
+        [this]<class Context>(Context& ctx) noexcept
+        {
+          aVoidAPI(&ctx,
+                   [](void* pv)
+                   {
+                     Context& ctx           = *static_cast<Context*>(pv);
+                     *std::get<0>(ctx.args) = true;
+                     ex::set_value(std::move(ctx.receiver));
+                   });
         },
         &called);
     }();
@@ -102,4 +124,4 @@ namespace {
     CHECK(res.has_value());
     CHECK(called);
   }
-} // anonymous namespace
+}  // anonymous namespace
diff --git a/test/exec/test_ensure_started.cpp b/test/exec/test_ensure_started.cpp
index 9a7f4e2c7..9ecf853ab 100644
--- a/test/exec/test_ensure_started.cpp
+++ b/test/exec/test_ensure_started.cpp
@@ -28,23 +28,27 @@
 namespace ex = STDEXEC;
 using exec::async_scope;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("ensure_started returns a sender", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started returns a sender", "[adaptors][ensure_started]")
+  {
     auto snd = exec::ensure_started(ex::just(19));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  static const auto env = ex::prop{ex::get_scheduler, inline_scheduler{}};
+  static auto const env = ex::prop{ex::get_scheduler, inline_scheduler{}};
 
-  TEST_CASE("ensure_started with environment returns a sender", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started with environment returns a sender", "[adaptors][ensure_started]")
+  {
     auto snd = exec::ensure_started(ex::just(19), env);
     static_assert(ex::sender_in<decltype(snd), decltype(env)>);
     (void) snd;
   }
 
-  TEST_CASE("ensure_started void value early", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started void value early", "[adaptors][ensure_started]")
+  {
     bool called{false};
     auto snd1 = ex::just() | ex::then([&] { called = true; });
     CHECK_FALSE(called);
@@ -54,10 +58,11 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started void value late", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started void value late", "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called{false};
-    auto snd1 = ex::starts_on(sch, ex::just()) | ex::then([&] { called = true; });
+    bool              called{false};
+    auto              snd1 = ex::starts_on(sch, ex::just()) | ex::then([&] { called = true; });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK_FALSE(called);
@@ -68,12 +73,16 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started single value early", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started single value early", "[adaptors][ensure_started]")
+  {
     bool called{false};
-    auto snd1 = ex::just() | ex::then([&] {
-                  called = true;
-                  return 42;
-                });
+    auto snd1 = ex::just()
+              | ex::then(
+                  [&]
+                  {
+                    called = true;
+                    return 42;
+                  });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK(called);
@@ -81,13 +90,17 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started single value late", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started single value late", "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called{false};
-    auto snd1 = ex::starts_on(sch, ex::just()) | ex::then([&] {
-                  called = true;
-                  return 42;
-                });
+    bool              called{false};
+    auto              snd1 = ex::starts_on(sch, ex::just())
+              | ex::then(
+                  [&]
+                  {
+                    called = true;
+                    return 42;
+                  });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK_FALSE(called);
@@ -98,12 +111,15 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started multiple values early", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started multiple values early", "[adaptors][ensure_started]")
+  {
     bool called{false};
-    auto snd1 = ex::let_value(ex::just(), [&] {
-      called = true;
-      return ex::just(42, movable{56});
-    });
+    auto snd1 = ex::let_value(ex::just(),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just(42, movable{56});
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK(called);
@@ -111,13 +127,16 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started multiple values late", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started multiple values late", "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called{false};
-    auto snd1 = ex::let_value(ex::starts_on(sch, ex::just()), [&] {
-      called = true;
-      return ex::just(42, movable{56});
-    });
+    bool              called{false};
+    auto              snd1 = ex::let_value(ex::starts_on(sch, ex::just()),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just(42, movable{56});
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK_FALSE(called);
@@ -128,12 +147,15 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started error early", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started error early", "[adaptors][ensure_started]")
+  {
     bool called{false};
-    auto snd1 = ex::let_value(ex::just(), [&] {
-      called = true;
-      return ex::just_error(42);
-    });
+    auto snd1 = ex::let_value(ex::just(),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just_error(42);
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK(called);
@@ -141,13 +163,16 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started error late", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started error late", "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called{false};
-    auto snd1 = ex::let_value(ex::starts_on(sch, ex::just()), [&] {
-      called = true;
-      return ex::just_error(42);
-    });
+    bool              called{false};
+    auto              snd1 = ex::let_value(ex::starts_on(sch, ex::just()),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just_error(42);
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK_FALSE(called);
@@ -158,12 +183,15 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started stopped early", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started stopped early", "[adaptors][ensure_started]")
+  {
     bool called{false};
-    auto snd1 = ex::let_value(ex::just(), [&] {
-      called = true;
-      return ex::just_stopped();
-    });
+    auto snd1 = ex::let_value(ex::just(),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just_stopped();
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK(called);
@@ -171,13 +199,16 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started stopped late", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started stopped late", "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called{false};
-    auto snd1 = ex::let_value(ex::starts_on(sch, ex::just()), [&] {
-      called = true;
-      return ex::just_stopped();
-    });
+    bool              called{false};
+    auto              snd1 = ex::let_value(ex::starts_on(sch, ex::just()),
+                              [&]
+                              {
+                                called = true;
+                                return ex::just_stopped();
+                              });
     CHECK_FALSE(called);
     auto snd = exec::ensure_started(std::move(snd1));
     CHECK_FALSE(called);
@@ -188,13 +219,13 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE(
-    "stopping ensure_started before the source completes calls set_stopped",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("stopping ensure_started before the source completes calls set_stopped",
+            "[adaptors][ensure_started]")
+  {
     ex::inplace_stop_source stop_source;
-    impulse_scheduler sch;
-    bool called{false};
-    auto snd = ex::starts_on(sch, ex::just(19))
+    impulse_scheduler       sch;
+    bool                    called{false};
+    auto                    snd = ex::starts_on(sch, ex::just(19))
              | ex::write_env(ex::prop{ex::get_stop_token, stop_source.get_token()})
              | exec::ensure_started();
     auto op = ex::connect(std::move(snd), expect_stopped_receiver_ex{called});
@@ -206,16 +237,15 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE(
-    "stopping ensure_started before the lazy opstate is started calls set_stopped",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("stopping ensure_started before the lazy opstate is started calls set_stopped",
+            "[adaptors][ensure_started]")
+  {
     ex::inplace_stop_source stop_source;
-    impulse_scheduler sch;
-    int count = 0;
-    bool called{false};
-    auto snd = ex::let_value(
-                 ex::just() | ex::then([&] { ++count; }),
-                 [=] { return ex::starts_on(sch, ex::just(19)); })
+    impulse_scheduler       sch;
+    int                     count = 0;
+    bool                    called{false};
+    auto                    snd = ex::let_value(ex::just() | ex::then([&] { ++count; }),
+                             [=] { return ex::starts_on(sch, ex::just(19)); })
              | ex::write_env(ex::prop{ex::get_stop_token, stop_source.get_token()})
              | exec::ensure_started();
     CHECK(count == 1);
@@ -228,15 +258,19 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE(
-    "stopping ensure_started after the task has already completed doesn't change the result",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("stopping ensure_started after the task has already completed doesn't change the "
+            "result",
+            "[adaptors][ensure_started]")
+  {
     ex::inplace_stop_source stop_source;
-    int count = 0;
-    auto snd = ex::just() | ex::then([&] {
-                 ++count;
-                 return 42;
-               })
+    int                     count = 0;
+    auto                    snd   = ex::just()
+             | ex::then(
+                 [&]
+                 {
+                   ++count;
+                   return 42;
+                 })
              | ex::write_env(ex::prop{ex::get_stop_token, stop_source.get_token()})
              | exec::ensure_started();
     CHECK(count == 1);
@@ -246,11 +280,11 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE(
-    "Dropping the sender without connecting it calls set_stopped",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("Dropping the sender without connecting it calls set_stopped",
+            "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    bool called = false;
+    bool              called = false;
     {
       auto snd = ex::starts_on(sch, ex::just()) | ex::upon_stopped([&] { called = true; })
                | exec::ensure_started();
@@ -260,12 +294,12 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE(
-    "Dropping the opstate without starting it calls set_stopped",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("Dropping the opstate without starting it calls set_stopped",
+            "[adaptors][ensure_started]")
+  {
     impulse_scheduler sch;
-    int state = -1;
-    bool called = false;
+    int               state  = -1;
+    bool              called = false;
     {
       auto snd = ex::starts_on(sch, ex::just()) | ex::upon_stopped([&] { called = true; })
                | exec::ensure_started();
@@ -278,19 +312,21 @@ namespace {
     CHECK(state == -1);
   }
 
-  TEST_CASE("Repeated ensure_started compiles", "[adaptors][ensure_started]") {
+  TEST_CASE("Repeated ensure_started compiles", "[adaptors][ensure_started]")
+  {
     bool called{false};
     auto snd1 = ex::just() | ex::then([&] { called = true; });
     CHECK_FALSE(called);
     auto snd2 = exec::ensure_started(std::move(snd1));
-    auto snd = exec::ensure_started(std::move(snd2));
+    auto snd  = exec::ensure_started(std::move(snd2));
     STATIC_REQUIRE(std::same_as<decltype(snd2), decltype(snd)>);
     CHECK(called);
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("ensure_started with move only input sender", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started with move only input sender", "[adaptors][ensure_started]")
+  {
     bool called{false};
     auto snd1 = ex::just(movable(42)) | ex::then([&](movable&&) { called = true; });
     CHECK_FALSE(called);
@@ -300,27 +336,30 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE(
-    "Repeated ensure_started with operator| does not return reference to temporary",
-    "[adaptors][ensure_started]") {
+  TEST_CASE("Repeated ensure_started with operator| does not return reference to temporary",
+            "[adaptors][ensure_started]")
+  {
     auto snd = exec::ensure_started(ex::just()) | exec::ensure_started();
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  struct my_sender {
+  struct my_sender
+  {
     using sender_concept = ex::sender_t;
-    using is_sender = void;
+    using is_sender      = void;
 
     using completion_signatures = ex::completion_signatures_of_t<decltype(ex::just())>;
 
     template <class Recv>
-    auto connect(Recv&& recv) const {
+    auto connect(Recv&& recv) const
+    {
       return ex::connect(ex::just(), std::forward<Recv>(recv));
     }
   };
 
-  TEST_CASE("ensure_started accepts a custom sender", "[adaptors][ensure_started]") {
+  TEST_CASE("ensure_started accepts a custom sender", "[adaptors][ensure_started]")
+  {
     auto snd1 = my_sender();
     auto snd2 = exec::ensure_started(std::move(snd1));
     static_assert(ex::__well_formed_sender<decltype(snd1)>);
@@ -333,4 +372,4 @@ namespace {
     (void) snd2;
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/test_env.cpp b/test/exec/test_env.cpp
index ddc6c413b..373597718 100644
--- a/test/exec/test_env.cpp
+++ b/test/exec/test_env.cpp
@@ -18,21 +18,26 @@
 #include <exec/env.hpp>
 #include <stdexec/execution.hpp>
 
-namespace {
+namespace
+{
   // Two dummy properties:
   constexpr struct Foo
     : STDEXEC::__query<Foo>
-    , STDEXEC::forwarding_query_t {
+    , STDEXEC::forwarding_query_t
+  {
     using STDEXEC::__query<Foo>::operator();
   } foo{};
 
-  constexpr struct Bar : STDEXEC::__query<Bar> {
-    static constexpr auto query(STDEXEC::forwarding_query_t) noexcept -> bool {
+  constexpr struct Bar : STDEXEC::__query<Bar>
+  {
+    static constexpr auto query(STDEXEC::forwarding_query_t) noexcept -> bool
+    {
       return true;
     }
   } bar{};
 
-  TEST_CASE("Test make_env works", "[env]") {
+  TEST_CASE("Test make_env works", "[env]")
+  {
     auto e = STDEXEC::prop{foo, 42};
     CHECK(foo(e) == 42);
 
@@ -48,4 +53,4 @@ namespace {
     STATIC_REQUIRE(!std::invocable<Foo, decltype(e4)>);
     CHECK(bar(e4) == 43);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_execute.cpp b/test/exec/test_execute.cpp
index 5df5247c4..ececa14e1 100644
--- a/test/exec/test_execute.cpp
+++ b/test/exec/test_execute.cpp
@@ -22,7 +22,7 @@
 #include <test_common/schedulers.hpp>
 
 #include <atomic>
-#include <chrono> // IWYU pragma: keep for std::chrono_literals
+#include <chrono>  // IWYU pragma: keep for std::chrono_literals
 
 namespace ex = STDEXEC;
 
@@ -30,26 +30,27 @@ using namespace std::chrono_literals;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
 // Trying to test `execute` with error flows will result in calling `std::terminate()`.
 // We don't want that
 
-namespace {
+namespace
+{
 
-  TEST_CASE("execute works with inline scheduler", "[other][execute]") {
+  TEST_CASE("execute works with inline scheduler", "[other][execute]")
+  {
     inline_scheduler sched;
-    bool called{false};
+    bool             called{false};
     exec::execute(sched, [&] { called = true; });
     // The function should already have been called
     CHECK(called);
   }
 
-  TEST_CASE(
-    "execute works with schedulers that need to be triggered manually",
-    "[other][execute]") {
+  TEST_CASE("execute works with schedulers that need to be triggered manually", "[other][execute]")
+  {
     impulse_scheduler sched;
-    bool called{false};
+    bool              called{false};
     exec::execute(sched, [&] { called = true; });
     // The function has not yet been called
     CHECK_FALSE(called);
@@ -58,9 +59,10 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE("execute works on a thread pool", "[other][execute]") {
+  TEST_CASE("execute works on a thread pool", "[other][execute]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // launch some work on the thread pool
       exec::execute(pool.get_scheduler(), [&] { called.store(true, std::memory_order_relaxed); });
@@ -68,10 +70,11 @@ namespace {
     // wait for the work to be executed, with timeout
     // perform a poor-man's sync
     // NOTE: it's a shame that the `join` method in static_thread_pool is not public
-    for (int i = 0; i < 1000 && !called.load(std::memory_order_relaxed); i++) {
+    for (int i = 0; i < 1000 && !called.load(std::memory_order_relaxed); i++)
+    {
       std::this_thread::sleep_for(1ms);
     }
     // the work should be executed
     REQUIRE(called);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_fork.cpp b/test/exec/test_fork.cpp
index 846f17265..b67a67ba3 100644
--- a/test/exec/test_fork.cpp
+++ b/test/exec/test_fork.cpp
@@ -26,44 +26,47 @@
 
 using namespace STDEXEC;
 
-namespace {
-  TEST_CASE("fork_join is a sender", "[adaptors][fork_join]") {
-    auto sndr = exec::fork_join(just(), then([] { }));
+namespace
+{
+  TEST_CASE("fork_join is a sender", "[adaptors][fork_join]")
+  {
+    auto sndr = exec::fork_join(just(), then([] {}));
     STATIC_REQUIRE(sender<decltype(sndr)>);
   }
 
-  TEST_CASE("fork_join is a sender in empty env", "[adaptors][fork_join]") {
-    auto sndr = exec::fork_join(just(), then([] { }));
+  TEST_CASE("fork_join is a sender in empty env", "[adaptors][fork_join]")
+  {
+    auto sndr = exec::fork_join(just(), then([] {}));
     STATIC_REQUIRE(sender_in<decltype(sndr), env<>>);
     STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(sndr), env<>>,
-        completion_signatures<set_value_t(), set_error_t(std::exception_ptr)>
-      >);
+      set_equivalent<completion_signatures_of_t<decltype(sndr), env<>>,
+                     completion_signatures<set_value_t(), set_error_t(std::exception_ptr)>>);
   }
 
-  struct ForwardingThen {
+  struct ForwardingThen
+  {
     template <typename Value>
-    constexpr decltype(auto) operator()(Value&& value) const noexcept {
+    constexpr decltype(auto) operator()(Value &&value) const noexcept
+    {
       return std::forward<Value>(value);
     }
 
-    constexpr void operator()() const noexcept {
-    }
+    constexpr void operator()() const noexcept {}
   };
 
   template <char ID>
-  struct identifiable_domain : public STDEXEC::default_domain { };
+  struct identifiable_domain : public STDEXEC::default_domain
+  {};
 
-  TEST_CASE("fork_join completion domain and scheduler", "[adaptors][fork_join]") {
+  TEST_CASE("fork_join completion domain and scheduler", "[adaptors][fork_join]")
+  {
     basic_inline_scheduler<identifiable_domain<'A'>> sched_A;
     basic_inline_scheduler<identifiable_domain<'B'>> sched_B;
     basic_inline_scheduler<identifiable_domain<'C'>> sched_C;
 
     auto sndr = STDEXEC::schedule(sched_A) | STDEXEC::then(ForwardingThen{})
-              | exec::fork_join(
-                  STDEXEC::on(sched_B, STDEXEC::then(ForwardingThen{})),
-                  STDEXEC::on(sched_C, STDEXEC::then(ForwardingThen{})))
+              | exec::fork_join(STDEXEC::on(sched_B, STDEXEC::then(ForwardingThen{})),
+                                STDEXEC::on(sched_C, STDEXEC::then(ForwardingThen{})))
               | STDEXEC::then(ForwardingThen{});
 
     auto domain = STDEXEC::get_completion_domain<STDEXEC::set_value_t>(STDEXEC::get_env(sndr));
@@ -73,54 +76,58 @@ namespace {
     static_assert(std::same_as<decltype(sched), decltype(sched_A)>);
   }
 
-  TEST_CASE("fork_join broadcasts results to multiple continuations", "[adaptors][fork_join]") {
-    auto fn = [](auto sink) {
+  TEST_CASE("fork_join broadcasts results to multiple continuations", "[adaptors][fork_join]")
+  {
+    auto fn = [](auto sink)
+    {
       sink(42);
-      return completion_signatures<
-        set_value_t(int),
-        set_value_t(int, int),
-        set_value_t(int, int, int)
-      >{};
+      return completion_signatures<set_value_t(int),
+                                   set_value_t(int, int),
+                                   set_value_t(int, int, int)>{};
     };
-    auto sndr = exec::fork_join(
-      exec::just_from(fn),
-      then([](auto&&... is) {
-        CHECK(sizeof...(is) == 1);
-        CHECK(((is == 42) && ...));
-        STATIC_REQUIRE((std::is_same_v<decltype(is), const int&> && ...));
-        return (is + ...);
-      }),
-      then([](auto&&... is) {
-        CHECK(sizeof...(is) == 1);
-        CHECK(((is == 42) && ...));
-        STATIC_REQUIRE((std::is_same_v<decltype(is), const int&> && ...));
-        return (is + ...);
-      }));
+    auto sndr =
+      exec::fork_join(exec::just_from(fn),
+                      then(
+                        [](auto &&...is)
+                        {
+                          CHECK(sizeof...(is) == 1);
+                          CHECK(((is == 42) && ...));
+                          STATIC_REQUIRE((std::is_same_v<decltype(is), int const &> && ...));
+                          return (is + ...);
+                        }),
+                      then(
+                        [](auto &&...is)
+                        {
+                          CHECK(sizeof...(is) == 1);
+                          CHECK(((is == 42) && ...));
+                          STATIC_REQUIRE((std::is_same_v<decltype(is), int const &> && ...));
+                          return (is + ...);
+                        }));
     STATIC_REQUIRE(sender_in<decltype(sndr), env<>>);
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(sndr), env<>>,
-        completion_signatures<set_value_t(int, int), set_error_t(std::exception_ptr)>
-      >);
+    STATIC_REQUIRE(set_equivalent<
+                   completion_signatures_of_t<decltype(sndr), env<>>,
+                   completion_signatures<set_value_t(int, int), set_error_t(std::exception_ptr)>>);
 
     auto [i1, i2] = sync_wait(sndr).value();
     CHECK(i1 == 42);
     CHECK(i2 == 42);
   }
 
-  TEST_CASE("fork_join with empty value channel", "[adaptors][fork_join]") {
-    auto sndr = ::STDEXEC::just() | ::STDEXEC::then([]() noexcept -> void { })
-              | exec::fork_join(
-                  ::STDEXEC::then([]() noexcept -> void { }),
-                  ::STDEXEC::then([]() noexcept -> void { }));
+  TEST_CASE("fork_join with empty value channel", "[adaptors][fork_join]")
+  {
+    auto sndr = ::STDEXEC::just() | ::STDEXEC::then([]() noexcept -> void {})
+              | exec::fork_join(::STDEXEC::then([]() noexcept -> void {}),
+                                ::STDEXEC::then([]() noexcept -> void {}));
 
     ::STDEXEC::sync_wait(std::move(sndr));
   }
 
-  TEST_CASE("fork_join can be nested", "[adaptors][fork_join]") {
+  TEST_CASE("fork_join can be nested", "[adaptors][fork_join]")
+  {
     std::atomic<int> witness = 0;
 
-    auto make_then = [&witness]() {
+    auto make_then = [&witness]()
+    {
       return ::STDEXEC::then([&witness]() noexcept { ++witness; });
     };
 
@@ -132,29 +139,33 @@ namespace {
     CHECK(witness == 4);
   }
 
-  struct customize_fork_join_domain : public STDEXEC::default_domain {
+  struct customize_fork_join_domain : public STDEXEC::default_domain
+  {
     template <STDEXEC::sender_expr_for<exec::fork_join_t> Sndr, class Env>
-    constexpr auto transform_sender(STDEXEC::set_value_t, Sndr&&, const Env&) const noexcept {
+    constexpr auto transform_sender(STDEXEC::set_value_t, Sndr &&, Env const &) const noexcept
+    {
       return STDEXEC::just(std::string("congrats on customizing fork_join_t"));
     }
   };
 
-  TEST_CASE("fork_join is customizable", "[adaptors][fork_join]") {
+  TEST_CASE("fork_join is customizable", "[adaptors][fork_join]")
+  {
     basic_inline_scheduler<customize_fork_join_domain> sched{};
 
-    auto sndr =
-      ::STDEXEC::schedule(sched) | ::STDEXEC::then(ForwardingThen{})
-      | exec::fork_join(::STDEXEC::then(ForwardingThen{}), ::STDEXEC::then(ForwardingThen{}));
+    auto sndr = ::STDEXEC::schedule(sched) | ::STDEXEC::then(ForwardingThen{})
+              | exec::fork_join(::STDEXEC::then(ForwardingThen{}),
+                                ::STDEXEC::then(ForwardingThen{}));
 
-    CHECK(
-      std::get<0>(STDEXEC::sync_wait(std::move(sndr)).value())
-      == "congrats on customizing fork_join_t");
+    CHECK(std::get<0>(STDEXEC::sync_wait(std::move(sndr)).value())
+          == "congrats on customizing fork_join_t");
   }
 
-  TEST_CASE("fork_join following a continues_on", "[adaptors][fork_join]") {
+  TEST_CASE("fork_join following a continues_on", "[adaptors][fork_join]")
+  {
     std::atomic<int> witness = 0;
 
-    auto make_then = [&witness]() {
+    auto make_then = [&witness]()
+    {
       return ::STDEXEC::then([&witness]() noexcept { ++witness; });
     };
 
@@ -166,20 +177,23 @@ namespace {
     CHECK(witness == 2);
   }
 
-  TEST_CASE("fork_join with exec::static_thread_pool", "[adaptors][fork_join]") {
+  TEST_CASE("fork_join with exec::static_thread_pool", "[adaptors][fork_join]")
+  {
     std::atomic<int> witness{0};
 
     ::exec::static_thread_pool pool{4};
 
     auto sndr = ::STDEXEC::schedule(pool.get_scheduler())
-              | ::STDEXEC::then([&witness]() noexcept -> int {
-                  ++witness;
-                  return witness;
-                })
-              | ::exec::fork_join(
-                  ::STDEXEC::then([&witness](const int received) noexcept { witness += received; }),
-                  ::STDEXEC::then(
-                    [&witness](const int received) noexcept { witness += received; }));
+              | ::STDEXEC::then(
+                  [&witness]() noexcept -> int
+                  {
+                    ++witness;
+                    return witness;
+                  })
+              | ::exec::fork_join(::STDEXEC::then([&witness](int const received) noexcept
+                                                  { witness += received; }),
+                                  ::STDEXEC::then([&witness](int const received) noexcept
+                                                  { witness += received; }));
 
     static_assert(requires {
       {
@@ -191,4 +205,4 @@ namespace {
 
     CHECK(witness == 3);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_into_tuple.cpp b/test/exec/test_into_tuple.cpp
index 08fcdd496..81b0558ef 100644
--- a/test/exec/test_into_tuple.cpp
+++ b/test/exec/test_into_tuple.cpp
@@ -22,34 +22,35 @@
 
 using namespace STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("into_tuple is a sender", "[adaptors][into_tuple]") {
+  TEST_CASE("into_tuple is a sender", "[adaptors][into_tuple]")
+  {
     auto s = exec::into_tuple(just(42, 56));
     STATIC_REQUIRE(sender<decltype(s)>);
   }
 
-  TEST_CASE("into_tuple is a sender in empty env", "[adaptors][into_tuple]") {
+  TEST_CASE("into_tuple is a sender in empty env", "[adaptors][into_tuple]")
+  {
     using void_sender = result_of_t<exec::into_tuple, a_sender_of<set_value_t()>>;
     STATIC_REQUIRE(sender_in<void_sender, ex::env<>>);
     STATIC_REQUIRE(
       set_equivalent<
         completion_signatures_of_t<void_sender, ex::env<>>,
-        completion_signatures<set_error_t(std::exception_ptr), set_value_t(std::tuple<>)>
-      >);
+        completion_signatures<set_error_t(std::exception_ptr), set_value_t(std::tuple<>)>>);
 
     using ints_sender = result_of_t<exec::into_tuple, a_sender_of<set_value_t(int&, int)>>;
     STATIC_REQUIRE(sender_in<ints_sender, ex::env<>>);
     STATIC_REQUIRE(
       set_equivalent<
         completion_signatures_of_t<ints_sender, ex::env<>>,
-        completion_signatures<set_error_t(std::exception_ptr), set_value_t(std::tuple<int, int>)>
-      >);
+        completion_signatures<set_error_t(std::exception_ptr), set_value_t(std::tuple<int, int>)>>);
   }
 
-  TEST_CASE(
-    "into_tuple rejects senders unless they have a single value completion",
-    "[adaptors][into_tuple]") {
+  TEST_CASE("into_tuple rejects senders unless they have a single value completion",
+            "[adaptors][into_tuple]")
+  {
     using error_sender =
       result_of_t<exec::into_tuple, a_sender_of<set_error_t(std::exception_ptr)>>;
     STATIC_REQUIRE_FALSE(sender_in<error_sender, ex::env<>>);
@@ -62,10 +63,11 @@ namespace {
     STATIC_REQUIRE_FALSE(sender_in<multi_value_sender, ex::env<>>);
   }
 
-  TEST_CASE("trivial into_tuple example works", "[adaptors][into_tuple]") {
-    auto s = exec::into_tuple(just(42, 56));
+  TEST_CASE("trivial into_tuple example works", "[adaptors][into_tuple]")
+  {
+    auto s      = exec::into_tuple(just(42, 56));
     auto [i, j] = get<0>(sync_wait(s).value());
     CHECK(i == 42);
     CHECK(j == 56);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_io_uring_context.cpp b/test/exec/test_io_uring_context.cpp
index 5c259ea26..27e752675 100644
--- a/test/exec/test_io_uring_context.cpp
+++ b/test/exec/test_io_uring_context.cpp
@@ -33,160 +33,186 @@ using namespace STDEXEC;
 using namespace exec;
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
   // clang-12 does not know jthread yet
-  class jthread {
+  class jthread
+  {
     std::thread thread_;
 
    public:
     template <typename Callable, typename... Args>
     explicit jthread(Callable&& callable, Args&&... args)
-      : thread_(std::forward<Callable>(callable), std::forward<Args>(args)...) {
-    }
+      : thread_(std::forward<Callable>(callable), std::forward<Args>(args)...)
+    {}
 
     jthread(jthread&& other) noexcept
-      : thread_(std::move(other.thread_)) {
-    }
+      : thread_(std::move(other.thread_))
+    {}
 
-    auto operator=(jthread&& other) noexcept -> jthread& {
+    auto operator=(jthread&& other) noexcept -> jthread&
+    {
       thread_ = std::move(other.thread_);
       return *this;
     }
 
-    ~jthread() {
-      if (thread_.joinable()) {
+    ~jthread()
+    {
+      if (thread_.joinable())
+      {
         thread_.join();
       }
     }
 
     [[nodiscard]]
-    auto get_id() const noexcept -> std::thread::id {
+    auto get_id() const noexcept -> std::thread::id
+    {
       return thread_.get_id();
     }
   };
 
-  TEST_CASE("io_uring_context - unused context", "[types][io_uring][schedulers]") {
+  TEST_CASE("io_uring_context - unused context", "[types][io_uring][schedulers]")
+  {
     io_uring_context context;
     CHECK(context.is_running() == false);
   }
 
-  TEST_CASE("io_uring_context Satisfy concepts", "[types][io_uring][schedulers]") {
+  TEST_CASE("io_uring_context Satisfy concepts", "[types][io_uring][schedulers]")
+  {
     STATIC_REQUIRE(timed_scheduler<io_uring_scheduler>);
     STATIC_REQUIRE_FALSE(std::is_move_assignable_v<io_uring_context>);
   }
 
-  TEST_CASE("io_uring_context Schedule runs in io thread", "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Schedule runs in io thread", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    jthread io_thread{[&] { context.run_until_stopped(); }};
+    jthread            io_thread{[&] { context.run_until_stopped(); }};
     {
       scope_guard guard{[&]() noexcept { context.request_stop(); }};
-      bool is_called = false;
-      sync_wait(schedule(scheduler) | then([&] {
-                  CHECK(io_thread.get_id() == std::this_thread::get_id());
-                  is_called = true;
-                }));
+      bool        is_called = false;
+      sync_wait(schedule(scheduler)
+                | then(
+                  [&]
+                  {
+                    CHECK(io_thread.get_id() == std::this_thread::get_id());
+                    is_called = true;
+                  }));
       CHECK(is_called);
 
       is_called = false;
-      sync_wait(schedule_after(scheduler, 1ms) | then([&] {
-                  CHECK(io_thread.get_id() == std::this_thread::get_id());
-                  is_called = true;
-                }));
+      sync_wait(schedule_after(scheduler, 1ms)
+                | then(
+                  [&]
+                  {
+                    CHECK(io_thread.get_id() == std::this_thread::get_id());
+                    is_called = true;
+                  }));
       CHECK(is_called);
     }
   }
 
-  TEST_CASE(
-    "io_uring_context Call io_uring::run_until_empty with start_detached",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Call io_uring::run_until_empty with start_detached",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    bool is_called = false;
-    start_detached(schedule(scheduler) | then([&] {
-                     CHECK(context.is_running());
-                     is_called = true;
-                   }));
+    bool               is_called = false;
+    start_detached(schedule(scheduler)
+                   | then(
+                     [&]
+                     {
+                       CHECK(context.is_running());
+                       is_called = true;
+                     }));
     context.run_until_empty();
     CHECK(is_called);
     CHECK(!context.is_running());
     CHECK(!context.stop_requested());
   }
 
-  TEST_CASE(
-    "io_uring_context Call now(io_uring) is running clock",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Call now(io_uring) is running clock", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    auto start = now(scheduler);
+    auto               start     = now(scheduler);
     std::this_thread::sleep_for(10ms);
     CHECK(start + 10ms <= now(scheduler));
   }
 
-  TEST_CASE(
-    "io_uring_context Call io_uring::run_until_empty with sync_wait",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Call io_uring::run_until_empty with sync_wait",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    auto just_run = just() | then([&] { context.run_until_empty(); });
-    bool is_called = false;
-    sync_wait(when_all(
-      schedule_after(scheduler, 500us) | then([&] {
-        CHECK(context.is_running());
-        is_called = true;
-      }),
-      just_run));
+    auto               just_run  = just() | then([&] { context.run_until_empty(); });
+    bool               is_called = false;
+    sync_wait(when_all(schedule_after(scheduler, 500us)
+                         | then(
+                           [&]
+                           {
+                             CHECK(context.is_running());
+                             is_called = true;
+                           }),
+                       just_run));
     CHECK(is_called);
     CHECK(!context.is_running());
     CHECK(!context.stop_requested());
   }
 
-  TEST_CASE(
-    "io_uring_context Call io_uring::run with sync_wait and when_any",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Call io_uring::run with sync_wait and when_any",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    bool is_called = false;
-    sync_wait(when_any(
-      schedule_after(scheduler, 500us) | then([&] {
-        CHECK(context.is_running());
-        is_called = true;
-      }),
-      context.run()));
+    bool               is_called = false;
+    sync_wait(when_any(schedule_after(scheduler, 500us)
+                         | then(
+                           [&]
+                           {
+                             CHECK(context.is_running());
+                             is_called = true;
+                           }),
+                       context.run()));
     CHECK(is_called);
     CHECK(!context.is_running());
     CHECK(context.stop_requested());
   }
 
-  TEST_CASE(
-    "io_uring_context Call io_uring::run with sync_wait and when_all",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Call io_uring::run with sync_wait and when_all",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    bool is_called = false;
-    sync_wait(when_all(
-      schedule_after(scheduler, 500us) | then([&] {
-        CHECK(context.is_running());
-        is_called = true;
-      }),
-      context.run(until::empty)));
+    bool               is_called = false;
+    sync_wait(when_all(schedule_after(scheduler, 500us)
+                         | then(
+                           [&]
+                           {
+                             CHECK(context.is_running());
+                             is_called = true;
+                           }),
+                       context.run(until::empty)));
     CHECK(is_called);
     CHECK(!context.is_running());
     CHECK(!context.stop_requested());
   }
 
-  TEST_CASE(
-    "io_uring_context Explicitly stop the io_uring_context",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Explicitly stop the io_uring_context",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
     {
       bool is_called = false;
-      start_detached(schedule(scheduler) | then([&] {
-                       CHECK(context.is_running());
-                       is_called = true;
-                     }));
+      start_detached(schedule(scheduler)
+                     | then(
+                       [&]
+                       {
+                         CHECK(context.is_running());
+                         is_called = true;
+                       }));
       context.run_until_empty();
       CHECK(is_called);
       CHECK(!context.is_running());
@@ -197,83 +223,86 @@ namespace {
     context.run_until_stopped();
     CHECK(context.stop_requested());
     bool is_stopped = false;
-    sync_wait(schedule(scheduler) | then([&] { CHECK(false); }) | STDEXEC::upon_stopped([&] {
-                is_stopped = true;
-              }));
+    sync_wait(schedule(scheduler) | then([&] { CHECK(false); })
+              | STDEXEC::upon_stopped([&] { is_stopped = true; }));
     CHECK(is_stopped);
   }
 
-  TEST_CASE(
-    "io_uring_context Thread-safe to schedule from multiple threads",
-    "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Thread-safe to schedule from multiple threads",
+            "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    jthread io_thread{[&] { context.run_until_stopped(); }};
-    auto fn = [&] {
+    jthread            io_thread{[&] { context.run_until_stopped(); }};
+    auto               fn = [&]
+    {
       CHECK(io_thread.get_id() == std::this_thread::get_id());
     };
     {
       scope_guard guard{[&]() noexcept { context.request_stop(); }};
-      jthread thread1{[&] {
-        for (int i = 0; i < 10; ++i) {
-          sync_wait(when_all(
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn),
-            schedule(scheduler) | then(fn)));
-        }
-      }};
-      jthread thread2{[&] {
-        for (int i = 0; i < 10; ++i) {
-          auto tp = std::chrono::steady_clock::now() + 500us;
-          sync_wait(when_all(
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn),
-            schedule_at(scheduler, tp) | then(fn)));
-        }
-      }};
-      jthread thread3{[&] {
-        for (int i = 0; i < 10; ++i) {
-          sync_wait(when_all(
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn),
-            schedule_after(scheduler, 500us) | then(fn)));
-        }
-      }};
+      jthread     thread1{[&]
+                      {
+                        for (int i = 0; i < 10; ++i)
+                        {
+                          sync_wait(when_all(schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn),
+                                             schedule(scheduler) | then(fn)));
+                        }
+                      }};
+      jthread     thread2{[&]
+                      {
+                        for (int i = 0; i < 10; ++i)
+                        {
+                          auto tp = std::chrono::steady_clock::now() + 500us;
+                          sync_wait(when_all(schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn),
+                                             schedule_at(scheduler, tp) | then(fn)));
+                        }
+                      }};
+      jthread     thread3{[&]
+                      {
+                        for (int i = 0; i < 10; ++i)
+                        {
+                          sync_wait(when_all(schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn),
+                                             schedule_after(scheduler, 500us) | then(fn)));
+                        }
+                      }};
     }
   }
 
-  TEST_CASE("io_uring_context Stop io_uring_context", "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context Stop io_uring_context", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    jthread io_thread{[&] { context.run_until_stopped(); }};
+    jthread            io_thread{[&] { context.run_until_stopped(); }};
     {
       single_thread_context ctx1{};
-      auto sch1 = ctx1.get_scheduler();
-      bool is_called = false;
-      sync_wait(finally(
-        schedule(scheduler) | then([&]() noexcept { is_called = true; }),
-        schedule(sch1) | then([&]() noexcept { context.request_stop(); })));
+      auto                  sch1      = ctx1.get_scheduler();
+      bool                  is_called = false;
+      sync_wait(finally(schedule(scheduler) | then([&]() noexcept { is_called = true; }),
+                        schedule(sch1) | then([&]() noexcept { context.request_stop(); })));
       CHECK(is_called);
     }
     bool is_called = false;
@@ -281,40 +310,46 @@ namespace {
     CHECK_FALSE(is_called);
   }
 
-  TEST_CASE("io_uring_context schedule_after 0s", "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context schedule_after 0s", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    jthread io_thread{[&] { context.run_until_stopped(); }};
+    jthread            io_thread{[&] { context.run_until_stopped(); }};
     {
       scope_guard guard{[&]() noexcept { context.request_stop(); }};
-      bool is_called = false;
-      sync_wait(when_any(
-        schedule_after(scheduler, 0s) | then([&] {
-          CHECK(io_thread.get_id() == std::this_thread::get_id());
-          is_called = true;
-        }),
-        schedule_after(scheduler, 5ms)));
+      bool        is_called = false;
+      sync_wait(when_any(schedule_after(scheduler, 0s)
+                           | then(
+                             [&]
+                             {
+                               CHECK(io_thread.get_id() == std::this_thread::get_id());
+                               is_called = true;
+                             }),
+                         schedule_after(scheduler, 5ms)));
       CHECK(is_called);
     }
   }
 
-  TEST_CASE("io_uring_context schedule_after -1s", "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context schedule_after -1s", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
-    jthread io_thread{[&] { context.run_until_stopped(); }};
+    jthread            io_thread{[&] { context.run_until_stopped(); }};
     {
       scope_guard guard{[&]() noexcept { context.request_stop(); }};
-      bool is_called_1 = false;
-      bool is_called_2 = false;
-      auto start = std::chrono::steady_clock::now();
-      auto timeout = 100ms;
-      sync_wait(when_any(
-        schedule_after(scheduler, -1s) | then([&] {
-          CHECK(io_thread.get_id() == std::this_thread::get_id());
-          is_called_1 = true;
-        }),
-        schedule_after(scheduler, timeout) | then([&] { is_called_2 = true; })));
-      auto end = std::chrono::steady_clock::now();
+      bool        is_called_1 = false;
+      bool        is_called_2 = false;
+      auto        start       = std::chrono::steady_clock::now();
+      auto        timeout     = 100ms;
+      sync_wait(when_any(schedule_after(scheduler, -1s)
+                           | then(
+                             [&]
+                             {
+                               CHECK(io_thread.get_id() == std::this_thread::get_id());
+                               is_called_1 = true;
+                             }),
+                         schedule_after(scheduler, timeout) | then([&] { is_called_2 = true; })));
+      auto                     end  = std::chrono::steady_clock::now();
       std::chrono::nanoseconds diff = end - start;
       CHECK(diff.count() < std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count());
       CHECK(is_called_1 == true);
@@ -322,8 +357,9 @@ namespace {
     }
   }
 
-  TEST_CASE("io_uring_context - reuse context after being used", "[types][io_uring][schedulers]") {
-    io_uring_context context;
+  TEST_CASE("io_uring_context - reuse context after being used", "[types][io_uring][schedulers]")
+  {
+    io_uring_context   context;
     io_uring_scheduler scheduler = context.get_scheduler();
     CHECK(sync_wait(exec::when_any(schedule(scheduler), context.run())));
     CHECK(!sync_wait(exec::when_any(schedule(scheduler), context.run())));
@@ -331,6 +367,6 @@ namespace {
     CHECK(sync_wait(exec::when_any(schedule(scheduler), context.run())));
     CHECK(!sync_wait(exec::when_any(schedule(scheduler), context.run())));
   }
-} // namespace
+}  // namespace
 
 #endif
diff --git a/test/exec/test_just_from.cpp b/test/exec/test_just_from.cpp
index 68b049b91..7c64b3291 100644
--- a/test/exec/test_just_from.cpp
+++ b/test/exec/test_just_from.cpp
@@ -20,9 +20,11 @@
 
 #include <catch2/catch.hpp>
 
-TEST_CASE("just_from is a sender", "[just_from]") {
-  SECTION("potentially throwing") {
-    auto s = exec::just_from([](auto sink) { return sink(42); });
+TEST_CASE("just_from is a sender", "[just_from]")
+{
+  SECTION("potentially throwing")
+  {
+    auto s  = exec::just_from([](auto sink) { return sink(42); });
     using S = decltype(s);
     STATIC_REQUIRE(ex::sender<S>);
     STATIC_REQUIRE(ex::sender_in<S>);
@@ -31,8 +33,9 @@ TEST_CASE("just_from is a sender", "[just_from]") {
     ::check_sends_stopped<false>(s);
   }
 
-  SECTION("not potentially throwing") {
-    auto s = exec::just_from([](auto sink) noexcept { return sink(42); });
+  SECTION("not potentially throwing")
+  {
+    auto s  = exec::just_from([](auto sink) noexcept { return sink(42); });
     using S = decltype(s);
     STATIC_REQUIRE(ex::sender<S>);
     STATIC_REQUIRE(ex::sender_in<S>);
@@ -42,7 +45,8 @@ TEST_CASE("just_from is a sender", "[just_from]") {
   }
 }
 
-TEST_CASE("just_from basically works", "[just_from]") {
+TEST_CASE("just_from basically works", "[just_from]")
+{
   auto s = exec::just_from([](auto sink) noexcept { return sink(42, 43, 44); });
   ::check_val_types<ex::__mset<pack<int, int, int>>>(s);
   ::check_err_types<ex::__mset<>>(s);
@@ -54,12 +58,17 @@ TEST_CASE("just_from basically works", "[just_from]") {
   CHECK(c == 44);
 }
 
-TEST_CASE("just_from with multiple completions", "[just_from]") {
-  auto fn = [](auto sink) noexcept {
-    if (sizeof(sink) == ~0ul) {
+TEST_CASE("just_from with multiple completions", "[just_from]")
+{
+  auto fn = [](auto sink) noexcept
+  {
+    if (sizeof(sink) == ~0ul)
+    {
       std::puts("sink(42)");
       sink(42);
-    } else {
+    }
+    else
+    {
       std::puts("sink(43, 44)");
       sink(43, 44);
     }
@@ -72,10 +81,12 @@ TEST_CASE("just_from with multiple completions", "[just_from]") {
 
   auto var = ex::sync_wait_with_variant(s).value();
   std::visit(
-    []<class Tupl>(Tupl tupl) {
+    []<class Tupl>(Tupl tupl)
+    {
       constexpr auto N = std::tuple_size_v<Tupl>;
       CHECK(N == 2);
-      if constexpr (N == 2) {
+      if constexpr (N == 2)
+      {
         CHECK_TUPLE(tupl == std::tuple{43, 44});
       }
     },
diff --git a/test/exec/test_libdispatch.cpp b/test/exec/test_libdispatch.cpp
index 9829e9506..f2c41f791 100644
--- a/test/exec/test_libdispatch.cpp
+++ b/test/exec/test_libdispatch.cpp
@@ -18,13 +18,16 @@
 #include "exec/libdispatch_queue.hpp"
 #include "stdexec/execution.hpp"
 
-namespace {
-  TEST_CASE("libdispatch queue should be able to process tasks") {
+namespace
+{
+  TEST_CASE("libdispatch queue should be able to process tasks")
+  {
     exec::libdispatch_queue queue;
-    auto sch = queue.get_scheduler();
+    auto                    sch = queue.get_scheduler();
 
     std::vector<int> data{1, 2, 3, 4, 5};
-    auto add = [](auto const & data) {
+    auto             add = [](auto const & data)
+    {
       return std::accumulate(std::begin(data), std::end(data), 0);
     };
     auto sender = STDEXEC::just(std::move(data)) | STDEXEC::continues_on(sch) | STDEXEC::then(add);
@@ -37,17 +40,20 @@ namespace {
     CHECK(res == 15);
   }
 
-  TEST_CASE(
-    "libdispatch queue bulk algorithm should call callback function with all allowed shapes") {
+  TEST_CASE("libdispatch queue bulk algorithm should call callback function with all allowed "
+            "shapes")
+  {
     exec::libdispatch_queue queue;
-    auto sch = queue.get_scheduler();
+    auto                    sch = queue.get_scheduler();
 
     std::vector<int> data{1, 2, 3, 4, 5};
-    auto size = data.size();
-    auto expensive_computation = [](auto i, auto& data) {
+    auto             size                  = data.size();
+    auto             expensive_computation = [](auto i, auto& data)
+    {
       data[i] = 2 * data[i];
     };
-    auto add = [](auto const & data) {
+    auto add = [](auto const & data)
+    {
       return std::accumulate(std::begin(data), std::end(data), 0);
     };
     auto sender = STDEXEC::just(std::move(data)) | STDEXEC::continues_on(sch)
@@ -61,33 +67,38 @@ namespace {
     CHECK(res == 30);
   }
 
-  TEST_CASE("libdispatch bulk should handle exceptions gracefully") {
+  TEST_CASE("libdispatch bulk should handle exceptions gracefully")
+  {
     exec::libdispatch_queue queue;
-    auto sch = queue.get_scheduler();
+    auto                    sch = queue.get_scheduler();
 
     std::vector<int> data{1, 2, 3, 4, 5};
-    auto size = data.size();
-    auto expensive_computation = [](auto i, auto data) {
+    auto             size                  = data.size();
+    auto             expensive_computation = [](auto i, auto data)
+    {
       if (i == 0)
         throw 999;
       return 2 * data[i];
     };
-    auto add = [](auto const & data) {
+    auto add = [](auto const & data)
+    {
       return std::accumulate(std::begin(data), std::end(data), 0);
     };
     auto sender = STDEXEC::just(std::move(data)) | STDEXEC::continues_on(sch)
                 | STDEXEC::bulk(STDEXEC::par, size, expensive_computation) | STDEXEC::then(add);
 
-
-    STDEXEC_TRY {
+    STDEXEC_TRY
+    {
       STDEXEC::sync_wait(sender);
       CHECK(false);
     }
-    STDEXEC_CATCH(int e) {
+    STDEXEC_CATCH(int e)
+    {
       CHECK(e == 999);
     }
-    STDEXEC_CATCH_ALL {
+    STDEXEC_CATCH_ALL
+    {
       FAIL("invalid exception caught");
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_materialize.cpp b/test/exec/test_materialize.cpp
index 2f8fb319c..26095b792 100644
--- a/test/exec/test_materialize.cpp
+++ b/test/exec/test_materialize.cpp
@@ -8,54 +8,45 @@
 using namespace STDEXEC;
 using namespace exec;
 
-namespace {
+namespace
+{
 
   template <class _Tag, class... _Args>
     requires __completion_tag<std::decay_t<_Tag>>
   using __dematerialize_value = completion_signatures<std::decay_t<_Tag>(_Args...)>;
 
-  TEST_CASE("materialize completion signatures", "[adaptors][materialize]") {
+  TEST_CASE("materialize completion signatures", "[adaptors][materialize]")
+  {
     auto just_ = materialize(just());
     static_assert(sender<decltype(just_)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_)>,
-                  completion_signatures<set_value_t(set_value_t)>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_)>,
+                                 completion_signatures<set_value_t(set_value_t)>>);
     auto demat_just = dematerialize(just_);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(demat_just)>,
-                  completion_signatures<set_value_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(demat_just)>,
+                                 completion_signatures<set_value_t()>>);
 
     auto just_string = materialize(just(std::string("foo")));
     static_assert(sender<decltype(just_string)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_string)>,
-                  completion_signatures<set_value_t(set_value_t, std::string)>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_string)>,
+                                 completion_signatures<set_value_t(set_value_t, std::string)>>);
 
     auto demat_just_string = dematerialize(just_string);
-    static_assert(std::same_as<
-                  completion_signatures_of_t<decltype(demat_just_string)>,
-                  completion_signatures<set_value_t(std::string)>
-    >);
+    static_assert(std::same_as<completion_signatures_of_t<decltype(demat_just_string)>,
+                               completion_signatures<set_value_t(std::string)>>);
 
     auto just_stopped_ = materialize(just_stopped());
     static_assert(sender<decltype(just_stopped_)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_stopped_)>,
-                  completion_signatures<set_value_t(set_stopped_t)>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_stopped_)>,
+                                 completion_signatures<set_value_t(set_stopped_t)>>);
     auto demat_just_stopped = dematerialize(just_stopped_);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(demat_just_stopped)>,
-                  completion_signatures<set_stopped_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(demat_just_stopped)>,
+                                 completion_signatures<set_stopped_t()>>);
     // wait_for_value(std::move(snd), movable(42));
   }
 
-  TEST_CASE("materialize value", "[adaptors][materialize]") {
-    auto just_42 = materialize(just(42));
+  TEST_CASE("materialize value", "[adaptors][materialize]")
+  {
+    auto just_42  = materialize(just(42));
     auto [tag, i] = *sync_wait(just_42);
     static_assert(std::same_as<decltype(tag), set_value_t>);
     static_assert(std::same_as<decltype(i), int>);
@@ -64,15 +55,17 @@ namespace {
     CHECK(i2 == 42);
   }
 
-  TEST_CASE("materialize stop", "[adaptors][materialize]") {
+  TEST_CASE("materialize stop", "[adaptors][materialize]")
+  {
     auto just_stop = materialize(just_stopped());
-    auto [tag] = *sync_wait(just_stop);
+    auto [tag]     = *sync_wait(just_stop);
     static_assert(std::same_as<decltype(tag), set_stopped_t>);
   }
 
-  TEST_CASE("dematerialize value", "[adaptors][materialize]") {
+  TEST_CASE("dematerialize value", "[adaptors][materialize]")
+  {
     auto just_42 = dematerialize(materialize(just(42)));
-    auto [i] = *sync_wait(just_42);
+    auto [i]     = *sync_wait(just_42);
     CHECK(i == 42);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_repeat_n.cpp b/test/exec/test_repeat_n.cpp
index a8c5ecd2c..3c22ec618 100644
--- a/test/exec/test_repeat_n.cpp
+++ b/test/exec/test_repeat_n.cpp
@@ -27,123 +27,140 @@
 
 using namespace STDEXEC;
 
-namespace {
-  TEST_CASE("repeat_n returns a sender", "[adaptors][repeat_n]") {
-    auto snd = exec::repeat_n(ex::just() | then([] { }), 10);
+namespace
+{
+  TEST_CASE("repeat_n returns a sender", "[adaptors][repeat_n]")
+  {
+    auto snd = exec::repeat_n(ex::just() | then([] {}), 10);
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("repeat_n with environment returns a sender", "[adaptors][repeat_n]") {
-    auto snd = exec::repeat_n(just() | then([] { }), 10);
+  TEST_CASE("repeat_n with environment returns a sender", "[adaptors][repeat_n]")
+  {
+    auto snd = exec::repeat_n(just() | then([] {}), 10);
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("repeat_n produces void value to downstream receiver", "[adaptors][repeat_n]") {
-    sender auto source = just(1) | then([](int) { });
-    sender auto snd = exec::repeat_n(std::move(source), 10);
+  TEST_CASE("repeat_n produces void value to downstream receiver", "[adaptors][repeat_n]")
+  {
+    sender auto source = just(1) | then([](int) {});
+    sender auto snd    = exec::repeat_n(std::move(source), 10);
     // The receiver checks if we receive the void value
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("simple example for repeat_n", "[adaptors][repeat_n]") {
+  TEST_CASE("simple example for repeat_n", "[adaptors][repeat_n]")
+  {
     sender auto snd = exec::repeat_n(just(), 2);
     ex::sync_wait(std::move(snd));
   }
 
-  TEST_CASE("repeat_n works with with zero repetitions", "[adaptors][repeat_n]") {
-    std::size_t count = 0;
-    ex::sender auto snd = just() | then([&count] { ++count; }) | exec::repeat_n(0)
+  TEST_CASE("repeat_n works with with zero repetitions", "[adaptors][repeat_n]")
+  {
+    std::size_t     count = 0;
+    ex::sender auto snd   = just() | then([&count] { ++count; }) | exec::repeat_n(0)
                         | then([] { return 1; });
     wait_for_value(std::move(snd), 1);
     CHECK(count == 0);
   }
 
-  TEST_CASE("repeat_n works with a single repetition", "[adaptors][repeat_n]") {
-    std::size_t count = 0;
-    ex::sender auto snd = just() | then([&count] { ++count; }) | exec::repeat_n(1)
+  TEST_CASE("repeat_n works with a single repetition", "[adaptors][repeat_n]")
+  {
+    std::size_t     count = 0;
+    ex::sender auto snd   = just() | then([&count] { ++count; }) | exec::repeat_n(1)
                         | then([] { return 1; });
     wait_for_value(std::move(snd), 1);
     CHECK(count == 1);
   }
 
-  TEST_CASE("repeat_n works with multiple repetitions", "[adaptors][repeat_n]") {
-    std::size_t count = 0;
-    ex::sender auto snd = just() | then([&count] { ++count; }) | exec::repeat_n(3)
+  TEST_CASE("repeat_n works with multiple repetitions", "[adaptors][repeat_n]")
+  {
+    std::size_t     count = 0;
+    ex::sender auto snd   = just() | then([&count] { ++count; }) | exec::repeat_n(3)
                         | then([] { return 1; });
     wait_for_value(std::move(snd), 1);
     CHECK(count == 3);
   }
 
-  TEST_CASE("repeat_n forwards set_error calls of other types", "[adaptors][repeat_n]") {
-    int count = 0;
-    auto snd = let_value(
-                 just(),
-                 [&] {
-                   ++count;
-                   return just_error(std::string("error"));
-                 })
+  TEST_CASE("repeat_n forwards set_error calls of other types", "[adaptors][repeat_n]")
+  {
+    int  count = 0;
+    auto snd   = let_value(just(),
+                         [&]
+                         {
+                           ++count;
+                           return just_error(std::string("error"));
+                         })
              | exec::repeat_n(10);
     auto op = ex::connect(std::move(snd), expect_error_receiver{std::string("error")});
     ex::start(op);
     CHECK(count == 1);
   }
 
-  TEST_CASE("repeat_n forwards set_stopped calls", "[adaptors][repeat_n]") {
-    int count = 0;
-    auto snd = let_value(
-                 just(),
-                 [&] {
-                   ++count;
-                   return just_stopped();
-                 })
+  TEST_CASE("repeat_n forwards set_stopped calls", "[adaptors][repeat_n]")
+  {
+    int  count = 0;
+    auto snd   = let_value(just(),
+                         [&]
+                         {
+                           ++count;
+                           return just_stopped();
+                         })
              | exec::repeat_n(10);
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     CHECK(count == 1);
   }
 
-  TEST_CASE(
-    "running deeply recursing algo on repeat_n doesn't blow the stack",
-    "[adaptors][repeat_n]") {
-    int n = 0;
+  TEST_CASE("running deeply recursing algo on repeat_n doesn't blow the stack",
+            "[adaptors][repeat_n]")
+  {
+    int         n   = 0;
     sender auto snd = exec::repeat_n(just() | then([&n] { ++n; }), 1'000'000);
     ex::sync_wait(std::move(snd));
     CHECK(n == 1'000'000);
   }
 
-  TEST_CASE("repeat_n works when changing threads", "[adaptors][repeat_n]") {
+  TEST_CASE("repeat_n works when changing threads", "[adaptors][repeat_n]")
+  {
     exec::static_thread_pool pool{2};
-    bool called{false};
-    sender auto snd = ex::on(pool.get_scheduler(), ex::just() | ex::then([&] {
-                                                     called = true;
-                                                   }) | exec::repeat_n(10));
+    bool                     called{false};
+    sender auto              snd = ex::on(pool.get_scheduler(),
+                             ex::just() | ex::then([&] { called = true; }) | exec::repeat_n(10));
     ex::sync_wait(std::move(snd));
     REQUIRE(called);
   }
 
-  TEST_CASE("repeat_n works with bulk on a static_thread_pool", "[adaptors][repeat_n]") {
+  TEST_CASE("repeat_n works with bulk on a static_thread_pool", "[adaptors][repeat_n]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> failed{false};
-    const auto tid = std::this_thread::get_id();
-    bool called{false};
-    sender auto snd =
-      ex::on(pool.get_scheduler(), ex::just() | ex::bulk(ex::par_unseq, 1024, [&](int) noexcept {
-                                     if (tid == std::this_thread::get_id()) {
-                                       failed = true;
-                                     }
-                                   }) | ex::then([&] {
-                                     called = true;
-                                   }) | exec::repeat_n(10));
+    std::atomic<bool>        failed{false};
+    auto const               tid = std::this_thread::get_id();
+    bool                     called{false};
+    sender auto              snd = ex::on(pool.get_scheduler(),
+                             ex::just()
+                               | ex::bulk(ex::par_unseq,
+                                          1024,
+                                          [&](int) noexcept
+                                          {
+                                            if (tid == std::this_thread::get_id())
+                                            {
+                                              failed = true;
+                                            }
+                                          })
+                               | ex::then([&] { called = true; }) | exec::repeat_n(10));
     ex::sync_wait(std::move(snd));
     REQUIRE(called);
     REQUIRE(!failed.load());
   }
 
-  TEST_CASE("repeat_n conditionally adds set_error_t(exception)", "[adaptors][repeat_n]") {
-    SECTION("ensure exception isn't always added") {
+  TEST_CASE("repeat_n conditionally adds set_error_t(exception)", "[adaptors][repeat_n]")
+  {
+    SECTION("ensure exception isn't always added")
+    {
       ex::sender auto snd = ex::just() | exec::repeat_n(1);
       static_assert(
         std::same_as<ex::error_types_of_t<decltype(snd)>, ex::__detail::__not_a_variant>,
@@ -153,29 +170,27 @@ namespace {
     // There are two main cases that will contribute set_error_t(std::exception_ptr)
     // 1. error's copy constructor could throw
     // 2. connect() could throw
-    SECTION("error completion is added when an error's copy ctor can throw") {
+    SECTION("error completion is added when an error's copy ctor can throw")
+    {
       // 1.
-      struct Error_with_throw_copy {
+      struct Error_with_throw_copy
+      {
         Error_with_throw_copy() noexcept = default;
-        Error_with_throw_copy(const Error_with_throw_copy&) noexcept(false) {};
+        Error_with_throw_copy(Error_with_throw_copy const &) noexcept(false) {};
       };
       ex::sender auto snd = ex::just_error(Error_with_throw_copy{}) | exec::repeat_n(1);
-      static_assert(
-        std::same_as<
-          ex::error_types_of_t<decltype(snd)>,
-          std::variant<Error_with_throw_copy, std::exception_ptr>
-        >,
-        "Missing added set_error_t(std::exception_ptr)");
+      static_assert(std::same_as<ex::error_types_of_t<decltype(snd)>,
+                                 std::variant<Error_with_throw_copy, std::exception_ptr>>,
+                    "Missing added set_error_t(std::exception_ptr)");
     }
 
-    SECTION("error completion is added when connect can throw") {
+    SECTION("error completion is added when connect can throw")
+    {
       // 2.
       using Sender_connect_throws = just_with_env<ex::env<>>;
       static_assert(
-        !ex::__error_types_t<
-          ex::completion_signatures_of_t<Sender_connect_throws>,
-          ex::__mcontains<ex::set_error_t(std::exception_ptr)>
-        >::value,
+        !ex::__error_types_t<ex::completion_signatures_of_t<Sender_connect_throws>,
+                             ex::__mcontains<ex::set_error_t(std::exception_ptr)>>::value,
         "Sender can't already emit exception to test if repeat_until() adds it");
       ex::sender auto snd = Sender_connect_throws{} | exec::repeat_n(1);
       static_assert(
@@ -184,4 +199,4 @@ namespace {
     }
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/test_repeat_n_fail.cpp b/test/exec/test_repeat_n_fail.cpp
index 28b73aab1..cfe5045f4 100644
--- a/test/exec/test_repeat_n_fail.cpp
+++ b/test/exec/test_repeat_n_fail.cpp
@@ -20,7 +20,8 @@
 
 namespace ex = STDEXEC;
 
-auto main() -> int {
+auto main() -> int
+{
   ex::sender auto snd = ex::just(42) | exec::repeat_n(10);
   // build error: _THE_INPUT_SENDER_MUST_HAVE_VOID_VALUE_COMPLETION_
   STDEXEC::sync_wait(std::move(snd));
diff --git a/test/exec/test_repeat_until.cpp b/test/exec/test_repeat_until.cpp
index 9401f6b94..0435bc33c 100644
--- a/test/exec/test_repeat_until.cpp
+++ b/test/exec/test_repeat_until.cpp
@@ -35,88 +35,99 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  struct boolean_sender {
+  struct boolean_sender
+  {
     using sender_concept = ex::sender_t;
     using completion_signatures =
-      ex::completion_signatures<ex::set_value_t(bool), ex::set_error_t(const int&)>;
+      ex::completion_signatures<ex::set_value_t(bool), ex::set_error_t(int const &)>;
 
     template <class Receiver>
-    struct operation {
+    struct operation
+    {
       Receiver rcvr_;
-      int counter_;
+      int      counter_;
 
-      void start() & noexcept {
-        if (counter_ == 0) {
+      void start() & noexcept
+      {
+        if (counter_ == 0)
+        {
           ex::set_value(static_cast<Receiver&&>(rcvr_), true);
-        } else {
+        }
+        else
+        {
           ex::set_value(static_cast<Receiver&&>(rcvr_), false);
         }
       }
     };
 
     template <ex::receiver_of<completion_signatures> Receiver>
-    auto connect(Receiver rcvr) const -> operation<Receiver> {
+    auto connect(Receiver rcvr) const -> operation<Receiver>
+    {
       return {static_cast<Receiver&&>(rcvr), --*counter_};
     }
 
     std::shared_ptr<int> counter_ = std::make_shared<int>(1000);
   };
 
-  TEST_CASE("repeat_until returns a sender", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until returns a sender", "[adaptors][repeat_until]")
+  {
     auto snd = exec::repeat_until(ex::just() | ex::then([] { return false; }));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("repeat_until with environment returns a sender", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until with environment returns a sender", "[adaptors][repeat_until]")
+  {
     auto snd = exec::repeat_until(ex::just() | ex::then([] { return true; }));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("repeat_until produces void value to downstream receiver", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until produces void value to downstream receiver", "[adaptors][repeat_until]")
+  {
     ex::sender auto source = ex::just(1) | ex::then([](int) { return true; });
-    ex::sender auto snd = exec::repeat_until(std::move(source));
+    ex::sender auto snd    = exec::repeat_until(std::move(source));
     // The receiver checks if we receive the void value
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("simple example for repeat_until", "[adaptors][repeat_until]") {
+  TEST_CASE("simple example for repeat_until", "[adaptors][repeat_until]")
+  {
     ex::sender auto snd = exec::repeat_until(boolean_sender{});
-    static_assert(all_contained_in<
-                  ex::completion_signatures<ex::set_error_t(const int&)>,
-                  ex::completion_signatures_of_t<decltype(snd), ex::env<>>
-    >);
-    static_assert(!all_contained_in<
-                  ex::completion_signatures<ex::set_error_t(int)>,
-                  ex::completion_signatures_of_t<decltype(snd), ex::env<>>
-    >);
+    static_assert(all_contained_in<ex::completion_signatures<ex::set_error_t(int const &)>,
+                                   ex::completion_signatures_of_t<decltype(snd), ex::env<>>>);
+    static_assert(!all_contained_in<ex::completion_signatures<ex::set_error_t(int)>,
+                                    ex::completion_signatures_of_t<decltype(snd), ex::env<>>>);
     ex::sync_wait(std::move(snd));
   }
 
-  TEST_CASE("repeat_until works with pipeline operator", "[adaptors][repeat_until]") {
-    bool should_stopped = true;
-    ex::sender auto snd = ex::just(should_stopped) | exec::repeat_until()
+  TEST_CASE("repeat_until works with pipeline operator", "[adaptors][repeat_until]")
+  {
+    bool            should_stopped = true;
+    ex::sender auto snd            = ex::just(should_stopped) | exec::repeat_until()
                         | ex::then([] { return 1; });
     wait_for_value(std::move(snd), 1);
   }
 
-  TEST_CASE(
-    "repeat_until works when input sender produces an int value",
-    "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until works when input sender produces an int value",
+            "[adaptors][repeat_until]")
+  {
     ex::sender auto snd = exec::repeat_until(ex::just(1));
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE(
-    "repeat_until works when input sender produces an object that can be converted to bool"
-    "[adaptors][repeat_until]") {
-    struct pred {
-      operator bool() {
+  TEST_CASE("repeat_until works when input sender produces an object that can be converted to bool"
+            "[adaptors][repeat_until]")
+  {
+    struct pred
+    {
+      operator bool()
+      {
         return --n <= 100;
       }
 
@@ -128,141 +139,175 @@ namespace {
     ex::sync_wait(exec::repeat_until(std::move(input_snd)));
   }
 
-  TEST_CASE("repeat_until forwards set_error calls of other types", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until forwards set_error calls of other types", "[adaptors][repeat_until]")
+  {
     auto snd = ex::just_error(std::string("error")) | exec::repeat_until();
-    auto op = ex::connect(std::move(snd), expect_error_receiver{std::string("error")});
+    auto op  = ex::connect(std::move(snd), expect_error_receiver{std::string("error")});
     ex::start(op);
   }
 
-  TEST_CASE("repeat_until forwards set_stopped calls", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until forwards set_stopped calls", "[adaptors][repeat_until]")
+  {
     auto snd = ex::just_stopped() | exec::repeat_until();
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE(
-    "running deeply recursing algo on repeat_until doesn't blow the stack",
-    "[adaptors][repeat_until]") {
-    int n = 1;
-    ex::sender auto snd = exec::repeat_until(ex::just() | ex::then([&n] {
-                                               ++n;
-                                               return n == 1'000'000;
-                                             }));
+  TEST_CASE("running deeply recursing algo on repeat_until doesn't blow the stack",
+            "[adaptors][repeat_until]")
+  {
+    int             n   = 1;
+    ex::sender auto snd = exec::repeat_until(ex::just()
+                                             | ex::then(
+                                               [&n]
+                                               {
+                                                 ++n;
+                                                 return n == 1'000'000;
+                                               }));
     ex::sync_wait(std::move(snd));
     CHECK(n == 1'000'000);
   }
 
-  TEST_CASE("repeat_until works when changing threads", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until works when changing threads", "[adaptors][repeat_until]")
+  {
     exec::static_thread_pool pool{2};
-    bool called{false};
-    ex::sender auto snd = ex::on(pool.get_scheduler(), ex::just() | ex::then([&] {
-                                                         called = true;
-                                                         return called;
-                                                       }) | exec::repeat_until());
+    bool                     called{false};
+    ex::sender auto          snd = ex::on(pool.get_scheduler(),
+                                 ex::just()
+                                   | ex::then(
+                                     [&]
+                                     {
+                                       called = true;
+                                       return called;
+                                     })
+                                   | exec::repeat_until());
     ex::sync_wait(std::move(snd));
 
     REQUIRE(called);
   }
 
-  TEST_CASE("repeat_until works with bulk on a static_thread_pool", "[adaptors][repeat_until]") {
+  TEST_CASE("repeat_until works with bulk on a static_thread_pool", "[adaptors][repeat_until]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> failed{false};
-    const auto tid = std::this_thread::get_id();
-    bool called{false};
-    ex::sender auto snd = STDEXEC::on(
-      pool.get_scheduler(), ex::just() | ex::bulk(ex::par_unseq, 1024, [&](int) noexcept {
-                              if (tid == std::this_thread::get_id()) {
-                                failed = true;
-                              }
-                            }) | ex::then([&] {
-                              called = true;
-                              return called;
-                            }) | exec::repeat_until());
+    std::atomic<bool>        failed{false};
+    auto const               tid = std::this_thread::get_id();
+    bool                     called{false};
+    ex::sender auto          snd = STDEXEC::on(pool.get_scheduler(),
+                                      ex::just()
+                                        | ex::bulk(ex::par_unseq,
+                                                   1024,
+                                                   [&](int) noexcept
+                                                   {
+                                                     if (tid == std::this_thread::get_id())
+                                                     {
+                                                       failed = true;
+                                                     }
+                                                   })
+                                        | ex::then(
+                                          [&]
+                                          {
+                                            called = true;
+                                            return called;
+                                          })
+                                        | exec::repeat_until());
     STDEXEC::sync_wait(std::move(snd));
     REQUIRE(called);
   }
 
   template <typename Receiver>
-  struct no_set_value_receiver : Receiver {
+  struct no_set_value_receiver : Receiver
+  {
     explicit no_set_value_receiver(Receiver r) noexcept
-      : Receiver(std::move(r)) {
-    }
+      : Receiver(std::move(r))
+    {}
     void set_value() && noexcept = delete;
   };
 
-  TEST_CASE("repeat repeats until an error is encountered", "[adaptors][repeat]") {
-    int counter = 0;
-    ex::sender auto snd = succeed_n_sender(10, ex::set_error, std::string("error")) //
-                        | ex::then([&] { ++counter; })                              //
+  TEST_CASE("repeat repeats until an error is encountered", "[adaptors][repeat]")
+  {
+    int             counter = 0;
+    ex::sender auto snd     = succeed_n_sender(10, ex::set_error, std::string("error"))  //
+                        | ex::then([&] { ++counter; })                                   //
                         | exec::repeat();
-    static_assert(!all_contained_in<
-                  ex::completion_signatures<ex::set_value_t()>,
-                  ex::completion_signatures_of_t<decltype(snd), ex::env<>>
-    >);
-    auto op = ex::connect(
-      std::move(snd), no_set_value_receiver(expect_error_receiver{std::string("error")}));
+    static_assert(!all_contained_in<ex::completion_signatures<ex::set_value_t()>,
+                                    ex::completion_signatures_of_t<decltype(snd), ex::env<>>>);
+    auto op = ex::connect(std::move(snd),
+                          no_set_value_receiver(expect_error_receiver{std::string("error")}));
     ex::start(op);
     REQUIRE(counter == 10);
   }
 
-  TEST_CASE("repeat repeats until stopped is encountered", "[adaptors][repeat]") {
-    int counter = 0;
-    ex::sender auto snd = exec::repeat(
-      succeed_n_sender(10, ex::set_stopped) | ex::then([&] { ++counter; }));
+  TEST_CASE("repeat repeats until stopped is encountered", "[adaptors][repeat]")
+  {
+    int             counter = 0;
+    ex::sender auto snd     = exec::repeat(succeed_n_sender(10, ex::set_stopped)
+                                       | ex::then([&] { ++counter; }));
     auto op = ex::connect(std::move(snd), no_set_value_receiver(expect_stopped_receiver{}));
     ex::start(op);
     REQUIRE(counter == 10);
   }
 
-  TEST_CASE(
-    "repeat works correctly when the child operation sends an error type which throws when "
-    "decay-copied",
-    "[adaptors][repeat]") {
-    struct error_type {
+  TEST_CASE("repeat works correctly when the child operation sends an error type which throws when "
+            "decay-copied",
+            "[adaptors][repeat]")
+  {
+    struct error_type
+    {
       explicit error_type(unsigned& throw_after) noexcept
-        : throw_after_(throw_after) {
-      }
-      error_type(const error_type& other)
-        : throw_after_(other.throw_after_) {
-        if (!throw_after_) {
+        : throw_after_(throw_after)
+      {}
+      error_type(error_type const & other)
+        : throw_after_(other.throw_after_)
+      {
+        if (!throw_after_)
+        {
           throw std::logic_error("TEST");
         }
         --throw_after_;
       }
       unsigned& throw_after_;
     };
-    struct receiver {
+    struct receiver
+    {
       using receiver_concept = ::STDEXEC::receiver_t;
-      void set_value() && noexcept {
+      void set_value() && noexcept
+      {
         FAIL_CHECK("Unexpected value completion signal");
       }
-      void set_stopped() && noexcept {
+      void set_stopped() && noexcept
+      {
         FAIL_CHECK("Unexpected stopped completion signal");
       }
-      void set_error(std::exception_ptr) && noexcept {
+      void set_error(std::exception_ptr) && noexcept
+      {
         CHECK(!done_);
       }
-      void set_error(const error_type&) && noexcept {
+      void set_error(error_type const &) && noexcept
+      {
         CHECK(!done_);
         done_ = true;
       }
       bool& done_;
     };
     unsigned throw_after = 0;
-    bool done = false;
-    do { // NOLINT(bugprone-infinite-loop)
-      const auto tmp = throw_after;
-      throw_after = std::numeric_limits<unsigned>::max();
+    bool     done        = false;
+    do
+    {  // NOLINT(bugprone-infinite-loop)
+      auto const tmp = throw_after;
+      throw_after    = std::numeric_limits<unsigned>::max();
       auto op = ex::connect(exec::repeat(ex::just_error(error_type(throw_after))), receiver(done));
       throw_after = tmp;
       ex::start(op);
       throw_after = tmp;
       ++throw_after;
-    } while (!done);
+    }
+    while (!done);
   }
 
-  TEST_CASE("repeat composes with completion signatures", "[adaptors][repeat]") {
-    SECTION("repeat composes with stopped upstream") {
+  TEST_CASE("repeat composes with completion signatures", "[adaptors][repeat]")
+  {
+    SECTION("repeat composes with stopped upstream")
+    {
       ex::sender auto only_stopped = ex::just_stopped() | exec::repeat();
       static_assert(
         std::same_as<ex::value_types_of_t<decltype(only_stopped)>, ex::__detail::__not_a_variant>,
@@ -270,88 +315,100 @@ namespace {
       static_assert(
         std::same_as<ex::error_types_of_t<decltype(only_stopped)>, ex::__detail::__not_a_variant>,
         "Expect no value completions");
-      static_assert(
-        ex::sender_of<decltype(only_stopped), ex::set_stopped_t()>,
-        "Missing set_stopped_t() from upstream");
+      static_assert(ex::sender_of<decltype(only_stopped), ex::set_stopped_t()>,
+                    "Missing set_stopped_t() from upstream");
 
       // operator| and sync_wait require valid completion signatures
       ex::sync_wait(only_stopped | ex::upon_stopped([]() noexcept { return -1; }));
     }
 
-    SECTION("repeat composes with errors upstream") {
+    SECTION("repeat composes with errors upstream")
+    {
       ex::sender auto only_error = ex::just_error(-1) | exec::repeat();
       static_assert(
         std::same_as<ex::value_types_of_t<decltype(only_error)>, ex::__detail::__not_a_variant>,
         "Expect no value completions");
-      static_assert(
-        std::same_as<ex::error_types_of_t<decltype(only_error)>, std::variant<int>>,
-        "Unexpected added set_error_t(std::exception_ptr)");
+      static_assert(std::same_as<ex::error_types_of_t<decltype(only_error)>, std::variant<int>>,
+                    "Unexpected added set_error_t(std::exception_ptr)");
 
       // set_stopped_t is always added as a consequence of the internal trampoline_scheduler
       using SC = ex::completion_signatures_of_t<ex::schedule_result_t<exec::trampoline_scheduler>>;
-      static_assert(
-        !ex::sender_of<SC, ex::set_stopped_t()>
-          || ex::sender_of<decltype(only_error), ex::set_stopped_t()>,
-        "Missing added set_stopped_t()");
+      static_assert(!ex::sender_of<SC, ex::set_stopped_t()>
+                      || ex::sender_of<decltype(only_error), ex::set_stopped_t()>,
+                    "Missing added set_stopped_t()");
 
       // operator| and sync_wait require valid completion signatures
-      ex::sync_wait(only_error | ex::upon_error([](const auto) { return -1; }));
+      ex::sync_wait(only_error | ex::upon_error([](auto const) { return -1; }));
     }
   }
 
-  TEST_CASE(
-    "repeat_until works correctly when the child operation sends type which throws when "
-    "decay-copied, and when converted to bool, and which is only rvalue convertible to bool",
-    "[adaptors][repeat_until]") {
-    class value_type {
-      void maybe_throw_() const {
-        if (!throw_after_) {
+  TEST_CASE("repeat_until works correctly when the child operation sends type which throws when "
+            "decay-copied, and when converted to bool, and which is only rvalue convertible to "
+            "bool",
+            "[adaptors][repeat_until]")
+  {
+    class value_type
+    {
+      void maybe_throw_() const
+      {
+        if (!throw_after_)
+        {
           throw std::logic_error("TEST");
         }
         --throw_after_;
       }
      public:
       explicit value_type(unsigned& throw_after) noexcept
-        : throw_after_(throw_after) {
-      }
-      value_type(const value_type& other)
-        : throw_after_(other.throw_after_) {
+        : throw_after_(throw_after)
+      {}
+      value_type(value_type const & other)
+        : throw_after_(other.throw_after_)
+      {
         maybe_throw_();
       }
       unsigned& throw_after_;
-      operator bool() && {
+                operator bool() &&
+      {
         maybe_throw_();
         return true;
       }
     };
-    struct receiver {
+    struct receiver
+    {
       using receiver_concept = ::STDEXEC::receiver_t;
-      void set_value() && noexcept {
+      void set_value() && noexcept
+      {
         done_ = true;
       }
-      void set_stopped() && noexcept {
+      void set_stopped() && noexcept
+      {
         FAIL_CHECK("Unexpected stopped completion signal");
       }
-      void set_error(std::exception_ptr) && noexcept {
+      void set_error(std::exception_ptr) && noexcept
+      {
         CHECK(!done_);
       }
       bool& done_;
     };
     unsigned throw_after = 0;
-    bool done = false;
-    do { // NOLINT(bugprone-infinite-loop)
-      const auto tmp = throw_after;
-      throw_after = std::numeric_limits<unsigned>::max();
+    bool     done        = false;
+    do
+    {  // NOLINT(bugprone-infinite-loop)
+      auto const tmp = throw_after;
+      throw_after    = std::numeric_limits<unsigned>::max();
       auto op = ex::connect(exec::repeat_until(ex::just(value_type(throw_after))), receiver(done));
       throw_after = tmp;
       ex::start(op);
       throw_after = tmp;
       ++throw_after;
-    } while (!done);
+    }
+    while (!done);
   }
 
-  TEST_CASE("repeat_until conditionally adds set_error_t(exception)", "[adaptors][repeat_until]") {
-    SECTION("ensure exception isn't always added") {
+  TEST_CASE("repeat_until conditionally adds set_error_t(exception)", "[adaptors][repeat_until]")
+  {
+    SECTION("ensure exception isn't always added")
+    {
       ex::sender auto snd = ex::just(false) | exec::repeat_until();
       static_assert(
         std::same_as<ex::error_types_of_t<decltype(snd)>, ex::__detail::__not_a_variant>,
@@ -362,11 +419,14 @@ namespace {
     // 1. value's conversion to bool could throw
     // 2. error's copy constructor could throw
     // 3. connect() could throw
-    SECTION("error completion is added when an error's copy ctor can throw") {
+    SECTION("error completion is added when an error's copy ctor can throw")
+    {
       // 1.
-      struct To_bool_can_throw {
+      struct To_bool_can_throw
+      {
         [[nodiscard]]
-        operator bool() const noexcept(false) {
+        operator bool() const noexcept(false)
+        {
           return true;
         }
       };
@@ -376,29 +436,27 @@ namespace {
         "Missing added set_error_t(std::exception_ptr)");
     }
 
-    SECTION("error completion is added when error->bool can throw") {
+    SECTION("error completion is added when error->bool can throw")
+    {
       // 2.
-      struct Error_with_throw_copy {
+      struct Error_with_throw_copy
+      {
         Error_with_throw_copy() noexcept = default;
-        Error_with_throw_copy(const Error_with_throw_copy&) noexcept(false) {};
+        Error_with_throw_copy(Error_with_throw_copy const &) noexcept(false) {};
       };
       ex::sender auto snd = ex::just_error(Error_with_throw_copy{}) | exec::repeat_until();
-      static_assert(
-        std::same_as<
-          ex::error_types_of_t<decltype(snd)>,
-          std::variant<Error_with_throw_copy, std::exception_ptr>
-        >,
-        "Missing added set_error_t(std::exception_ptr)");
+      static_assert(std::same_as<ex::error_types_of_t<decltype(snd)>,
+                                 std::variant<Error_with_throw_copy, std::exception_ptr>>,
+                    "Missing added set_error_t(std::exception_ptr)");
     }
 
-    SECTION("error completion is added when connect can throw") {
+    SECTION("error completion is added when connect can throw")
+    {
       // 3.
       using Sender_connect_throws = just_with_env<ex::env<>, bool>;
       static_assert(
-        !ex::__error_types_t<
-          ex::completion_signatures_of_t<Sender_connect_throws>,
-          ex::__mcontains<ex::set_error_t(std::exception_ptr)>
-        >::value,
+        !ex::__error_types_t<ex::completion_signatures_of_t<Sender_connect_throws>,
+                             ex::__mcontains<ex::set_error_t(std::exception_ptr)>>::value,
         "Sender can't already emit exception to test if repeat_until() adds it");
 
       ex::sender auto snd = Sender_connect_throws{{}, true} | exec::repeat_until();
@@ -407,4 +465,4 @@ namespace {
         "Missing added set_error_t(std::exception_ptr)");
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_repeat_until_fail.cpp b/test/exec/test_repeat_until_fail.cpp
index 650013b1e..ac13ab6e3 100644
--- a/test/exec/test_repeat_until_fail.cpp
+++ b/test/exec/test_repeat_until_fail.cpp
@@ -19,9 +19,11 @@
 
 namespace ex = STDEXEC;
 
-struct not_a_bool { };
+struct not_a_bool
+{};
 
-auto main() -> int {
+auto main() -> int
+{
   ex::sender auto snd = ex::just(not_a_bool()) | exec::repeat_until();
   // build error: _EXPECTING_A_SENDER_OF_ONE_VALUE_THAT_IS_CONVERTIBLE_TO_BOOL_
   STDEXEC::sync_wait(std::move(snd));
diff --git a/test/exec/test_sequence.cpp b/test/exec/test_sequence.cpp
index 8dcd09952..a20dc613a 100644
--- a/test/exec/test_sequence.cpp
+++ b/test/exec/test_sequence.cpp
@@ -23,45 +23,53 @@
 #include <exception>
 #include <memory>
 
-namespace {
-  struct big {
+namespace
+{
+  struct big
+  {
     std::unique_ptr<int[]> p{new int[1000]};
 
     big() = default;
 
-    auto operator==(const big&) const noexcept -> bool {
+    auto operator==(big const &) const noexcept -> bool
+    {
       return true;
     }
   };
 
-  struct connect_exception : std::exception {
+  struct connect_exception : std::exception
+  {
     connect_exception() = default;
 
     [[nodiscard]]
-    auto what() const noexcept -> const char* override {
+    auto what() const noexcept -> char const * override
+    {
       return "connect";
     }
   };
 
-  struct throwing_connect {
-    using sender_concept = ex::sender_t;
+  struct throwing_connect
+  {
+    using sender_concept        = ex::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
-    struct op {
+    struct op
+    {
       using operation_state_concept = ex::operation_state_t;
 
-      void start() & noexcept {
-      }
+      void start() & noexcept {}
     };
 
     [[nodiscard]]
-    auto connect(ex::__ignore) const -> op {
+    auto connect(ex::__ignore) const -> op
+    {
       STDEXEC_THROW(connect_exception{});
     }
   };
-} // namespace
+}  // namespace
 
-TEST_CASE("sequence produces a sender", "[sequence]") {
+TEST_CASE("sequence produces a sender", "[sequence]")
+{
   // The sequence algorithm requires at least one sender.
   STATIC_REQUIRE(!ex::__callable<exec::sequence_t>);
 
@@ -74,69 +82,80 @@ TEST_CASE("sequence produces a sender", "[sequence]") {
   check_sends_stopped<false>(s0);
 
   using env_t = ex::prop<ex::get_allocator_t, std::allocator<void>>;
-  auto s1 = exec::sequence(ex::just_error(42), ex::read_env(ex::get_allocator));
+  auto s1     = exec::sequence(ex::just_error(42), ex::read_env(ex::get_allocator));
   STATIC_REQUIRE(ex::sender<decltype(s1)>);
   STATIC_REQUIRE(ex::dependent_sender<decltype(s1)>);
   STATIC_REQUIRE(!ex::sender_in<decltype(s1)>);
   STATIC_REQUIRE(ex::sender_in<decltype(s1), env_t>);
-  check_val_types<ex::__mset<pack<const std::allocator<void>&>>, env_t>(s1);
+  check_val_types<ex::__mset<pack<std::allocator<void> const &>>, env_t>(s1);
   check_err_types<ex::__mset<std::exception_ptr, int>, env_t>(s1);
   check_sends_stopped<false, env_t>(s1);
 }
 
-TEST_CASE("sequence with one argument works", "[sequence]") {
-  SECTION("value completion") {
+TEST_CASE("sequence with one argument works", "[sequence]")
+{
+  SECTION("value completion")
+  {
     auto sndr = exec::sequence(ex::just(42));
-    auto op = ex::connect(std::move(sndr), expect_value_receiver{42});
+    auto op   = ex::connect(std::move(sndr), expect_value_receiver{42});
     ex::start(op);
   }
-  SECTION("error completion") {
+  SECTION("error completion")
+  {
     auto sndr = exec::sequence(ex::just_error(42));
-    auto op = ex::connect(std::move(sndr), expect_error_receiver{42});
+    auto op   = ex::connect(std::move(sndr), expect_error_receiver{42});
     ex::start(op);
   }
-  SECTION("stopped completion") {
+  SECTION("stopped completion")
+  {
     auto sndr = exec::sequence(ex::just_stopped());
-    auto op = ex::connect(std::move(sndr), expect_stopped_receiver{});
+    auto op   = ex::connect(std::move(sndr), expect_stopped_receiver{});
     ex::start(op);
   }
 }
 
-TEST_CASE("sequence with two arguments works", "[sequence]") {
-  SECTION("value completion") {
+TEST_CASE("sequence with two arguments works", "[sequence]")
+{
+  SECTION("value completion")
+  {
     auto sndr = exec::sequence(ex::just(big{}), ex::just(big{}, 4, 6, 8));
-    auto op = ex::connect(std::move(sndr), expect_value_receiver{big{}, 4, 6, 8});
+    auto op   = ex::connect(std::move(sndr), expect_value_receiver{big{}, 4, 6, 8});
     ex::start(op);
   }
-  SECTION("error completion 1") {
+  SECTION("error completion 1")
+  {
     auto sndr = exec::sequence(ex::just_error(big{}), ex::just(big{}, 4, 6, 8));
-    auto op = ex::connect(std::move(sndr), expect_error_receiver{big{}});
+    auto op   = ex::connect(std::move(sndr), expect_error_receiver{big{}});
     ex::start(op);
   }
-  SECTION("error completion 2") {
+  SECTION("error completion 2")
+  {
     auto sndr = exec::sequence(ex::just(big{}, 4, 6, 8), ex::just_error(big{}));
-    auto op = ex::connect(std::move(sndr), expect_error_receiver{big{}});
+    auto op   = ex::connect(std::move(sndr), expect_error_receiver{big{}});
     ex::start(op);
   }
-  SECTION("stopped completion 1") {
-    auto stop = ex::just(big{}) | ex::let_value([](auto&) { return ex::just_stopped(); });
+  SECTION("stopped completion 1")
+  {
+    auto stop = ex::just(big{}) | ex::let_value([](auto &) { return ex::just_stopped(); });
     auto sndr = exec::sequence(std::move(stop), ex::just(big{}, 4, 6, 8));
-    auto op = ex::connect(std::move(sndr), expect_stopped_receiver{});
+    auto op   = ex::connect(std::move(sndr), expect_stopped_receiver{});
     ex::start(op);
   }
-  SECTION("stopped completion 2") {
-    auto stop = ex::just(big{}) | ex::let_value([](auto&) { return ex::just_stopped(); });
+  SECTION("stopped completion 2")
+  {
+    auto stop = ex::just(big{}) | ex::let_value([](auto &) { return ex::just_stopped(); });
     auto sndr = exec::sequence(ex::just(big{}, 4, 6, 8), std::move(stop));
-    auto op = ex::connect(std::move(sndr), expect_stopped_receiver{});
+    auto op   = ex::connect(std::move(sndr), expect_stopped_receiver{});
     ex::start(op);
   }
 }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-TEST_CASE("sequence with sender with throwing connect", "[sequence]") {
-  auto err = std::make_exception_ptr(connect_exception{});
+TEST_CASE("sequence with sender with throwing connect", "[sequence]")
+{
+  auto err  = std::make_exception_ptr(connect_exception{});
   auto sndr = exec::sequence(ex::just(big{}), throwing_connect{}, ex::just(big{}, 42));
-  auto op = ex::connect(std::move(sndr), expect_error_receiver{err});
+  auto op   = ex::connect(std::move(sndr), expect_error_receiver{err});
   ex::start(op);
 }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
diff --git a/test/exec/test_sequence_senders.cpp b/test/exec/test_sequence_senders.cpp
index a398ebe6b..5a516e442 100644
--- a/test/exec/test_sequence_senders.cpp
+++ b/test/exec/test_sequence_senders.cpp
@@ -22,64 +22,64 @@
 using namespace STDEXEC;
 using namespace exec;
 
-namespace {
+namespace
+{
 
-  struct nop_operation {
-    void start() & noexcept {
-    }
+  struct nop_operation
+  {
+    void start() & noexcept {}
   };
 
-  TEST_CASE("sequence_senders - nop_operation is an operation state", "[sequence_senders]") {
+  TEST_CASE("sequence_senders - nop_operation is an operation state", "[sequence_senders]")
+  {
     STATIC_REQUIRE(operation_state<nop_operation>);
   }
 
   template <__completion_signature... _Sigs>
-  struct some_sender_of {
-    using sender_concept = STDEXEC::sender_t;
+  struct some_sender_of
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = STDEXEC::completion_signatures<_Sigs...>;
 
     template <class R>
-    auto connect(R&&) const -> nop_operation {
+    auto connect(R&&) const -> nop_operation
+    {
       return {};
     }
   };
 
-  TEST_CASE("sequence_senders - some_sender_of is a sender", "[sequence_senders]") {
+  TEST_CASE("sequence_senders - some_sender_of is a sender", "[sequence_senders]")
+  {
     STATIC_REQUIRE(sender<some_sender_of<set_value_t()>>);
     STATIC_REQUIRE(sender_in<some_sender_of<set_value_t()>, env<>>);
-    STATIC_REQUIRE(
-      std::same_as<
-        completion_signatures_of_t<some_sender_of<set_value_t()>>,
-        completion_signatures<set_value_t()>
-      >);
-    STATIC_REQUIRE(
-      std::same_as<
-        completion_signatures_of_t<some_sender_of<set_value_t(int)>>,
-        completion_signatures<set_value_t(int)>
-      >);
+    STATIC_REQUIRE(std::same_as<completion_signatures_of_t<some_sender_of<set_value_t()>>,
+                                completion_signatures<set_value_t()>>);
+    STATIC_REQUIRE(std::same_as<completion_signatures_of_t<some_sender_of<set_value_t(int)>>,
+                                completion_signatures<set_value_t(int)>>);
   }
 
   template <__completion_signature... _Sigs>
-  struct test_receiver {
+  struct test_receiver
+  {
     using receiver_concept = STDEXEC::receiver_t;
 
     template <class... _Args>
       requires __one_of<set_value_t(_Args...), _Sigs...>
-    void set_value(_Args&&...) noexcept {
-    }
+    void set_value(_Args&&...) noexcept
+    {}
 
     template <class E>
       requires __one_of<set_error_t(E), _Sigs...>
-    void set_error(E&&) noexcept {
-    }
+    void set_error(E&&) noexcept
+    {}
 
     void set_stopped() noexcept
       requires __one_of<set_stopped_t(), _Sigs...>
-    {
-    }
+    {}
   };
 
-  TEST_CASE("sequence_senders - test_receiver is a receiver of its Sigs", "[sequence_senders]") {
+  TEST_CASE("sequence_senders - test_receiver is a receiver of its Sigs", "[sequence_senders]")
+  {
     STATIC_REQUIRE(receiver<test_receiver<>>);
     STATIC_REQUIRE(receiver_of<test_receiver<set_value_t()>, completion_signatures<set_value_t()>>);
     STATIC_REQUIRE_FALSE(
@@ -98,28 +98,29 @@ namespace {
   }
 
   template <__completion_signature... _Sigs>
-  struct next_receiver {
+  struct next_receiver
+  {
     using receiver_concept = STDEXEC::receiver_t;
 
     template <sender_to<test_receiver<_Sigs...>> _Item>
-    auto set_next(_Item&& __item) & noexcept -> _Item {
+    auto set_next(_Item&& __item) & noexcept -> _Item
+    {
       return __item;
     }
 
-    void set_value() noexcept {
-    }
+    void set_value() noexcept {}
 
-    void set_stopped() noexcept {
-    }
+    void set_stopped() noexcept {}
 
     template <class E>
-    void set_error(E&&) noexcept {
-    }
+    void set_error(E&&) noexcept
+    {}
   };
 
-  TEST_CASE("sequence_senders - Test missing next signature", "[sequence_senders]") {
-    using just_t = decltype(just());
-    using just_int_t = decltype(just(0));
+  TEST_CASE("sequence_senders - Test missing next signature", "[sequence_senders]")
+  {
+    using just_t          = decltype(just());
+    using just_int_t      = decltype(just(0));
     using next_receiver_t = next_receiver<set_value_t(int)>;
     STATIC_REQUIRE(receiver<next_receiver_t>);
     STATIC_REQUIRE(sequence_receiver_of<next_receiver_t, item_types<just_int_t>>);
@@ -128,23 +129,26 @@ namespace {
   }
 
   template <__completion_signature... _Sigs>
-  struct some_sequence_sender_of {
-    using sender_concept = sequence_sender_t;
+  struct some_sequence_sender_of
+  {
+    using sender_concept        = sequence_sender_t;
     using completion_signatures = STDEXEC::completion_signatures<set_value_t()>;
-    using item_types = exec::item_types<some_sender_of<_Sigs...>>;
+    using item_types            = exec::item_types<some_sender_of<_Sigs...>>;
 
     template <receiver R>
-    auto subscribe(R&&) const -> nop_operation {
+    auto subscribe(R&&) const -> nop_operation
+    {
       return {};
     }
   };
 
-  TEST_CASE("sequence_senders - Test for subscribe", "[sequence_senders]") {
+  TEST_CASE("sequence_senders - Test for subscribe", "[sequence_senders]")
+  {
     using next_receiver_t = next_receiver<set_value_t(int), set_stopped_t()>;
-    using seq_sender_t = some_sequence_sender_of<set_value_t(int), set_stopped_t()>;
+    using seq_sender_t    = some_sequence_sender_of<set_value_t(int), set_stopped_t()>;
     STATIC_REQUIRE(sender<seq_sender_t>);
     STATIC_REQUIRE(sequence_sender<seq_sender_t, env<>>);
     STATIC_REQUIRE(sequence_sender_to<seq_sender_t, next_receiver_t>);
     STATIC_REQUIRE(sequence_sender_to<some_sequence_sender_of<set_value_t(int)>, next_receiver_t>);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_split.cpp b/test/exec/test_split.cpp
index fe9a24a91..e7df84a88 100644
--- a/test/exec/test_split.cpp
+++ b/test/exec/test_split.cpp
@@ -29,10 +29,12 @@ namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("split returns a sender", "[adaptors][split]") {
-    auto snd = exec::split(ex::just(19));
+  TEST_CASE("split returns a sender", "[adaptors][split]")
+  {
+    auto snd  = exec::split(ex::just(19));
     using Snd = decltype(snd);
     static_assert(ex::enable_sender<Snd>);
     static_assert(ex::sender<Snd>);
@@ -40,8 +42,9 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("split with environment returns a sender", "[adaptors][split]") {
-    auto snd = exec::split(ex::just(19));
+  TEST_CASE("split with environment returns a sender", "[adaptors][split]")
+  {
+    auto snd  = exec::split(ex::just(19));
     using Snd = decltype(snd);
     static_assert(ex::enable_sender<Snd>);
     static_assert(ex::sender_in<Snd, ex::env<>>);
@@ -49,7 +52,8 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("split simple example", "[adaptors][split]") {
+  TEST_CASE("split simple example", "[adaptors][split]")
+  {
     auto snd = exec::split(ex::just(19));
     auto op1 = ex::connect(snd, expect_value_receiver{19});
     auto op2 = ex::connect(snd, expect_value_receiver{19});
@@ -58,13 +62,18 @@ namespace {
     // The receiver will ensure that the right value is produced
   }
 
-  TEST_CASE("split executes predecessor sender once", "[adaptors][split]") {
-    SECTION("when parameters are passed") {
-      int counter{};
-      auto snd = exec::split(ex::just() | ex::then([&] {
-                             counter++;
-                             return counter;
-                           }));
+  TEST_CASE("split executes predecessor sender once", "[adaptors][split]")
+  {
+    SECTION("when parameters are passed")
+    {
+      int  counter{};
+      auto snd = exec::split(ex::just()
+                             | ex::then(
+                               [&]
+                               {
+                                 counter++;
+                                 return counter;
+                               }));
       auto op1 = ex::connect(snd, expect_value_receiver{1});
       auto op2 = ex::connect(snd, expect_value_receiver{1});
       REQUIRE(counter == 0);
@@ -75,27 +84,32 @@ namespace {
       REQUIRE(counter == 1);
     }
 
-    SECTION("without parameters") {
-      int counter{};
+    SECTION("without parameters")
+    {
+      int  counter{};
       auto snd = exec::split(ex::just() | ex::then([&] { counter++; }));
-      ex::sync_wait(snd | ex::then([] { }));
-      ex::sync_wait(snd | ex::then([] { }));
+      ex::sync_wait(snd | ex::then([] {}));
+      ex::sync_wait(snd | ex::then([] {}));
       REQUIRE(counter == 1);
     }
   }
 
-  TEST_CASE("split passes lvalue references", "[adaptors][split]") {
-    auto split = exec::split(ex::just(42));
+  TEST_CASE("split passes lvalue references", "[adaptors][split]")
+  {
+    auto split    = exec::split(ex::just(42));
     using split_t = decltype(split);
     using value_t = ex::value_types_of_t<split_t, ex::env<>, pack, ex::__mmake_set>;
-    static_assert(ex::__mset_eq<value_t, ex::__mset<pack<const int&>>>);
-
-    auto then = split | ex::then([](const int& cval) {
-                  int& val = const_cast<int&>(cval);
-                  const int prev_val = val;
-                  val /= 2;
-                  return prev_val;
-                });
+    static_assert(ex::__mset_eq<value_t, ex::__mset<pack<int const &>>>);
+
+    auto then = split
+              | ex::then(
+                  [](int const &cval)
+                  {
+                    int      &val      = const_cast<int &>(cval);
+                    int const prev_val = val;
+                    val /= 2;
+                    return prev_val;
+                  });
 
     auto op1 = ex::connect(std::move(then), expect_value_receiver{42});
     auto op2 = ex::connect(split, expect_value_receiver{21});
@@ -104,31 +118,35 @@ namespace {
     // The receiver will ensure that the right value is produced
   }
 
-  TEST_CASE("split forwards errors", "[adaptors][split]") {
-    SECTION("of exception_ptr type") {
-      auto split = exec::split(ex::just_error(std::exception_ptr{}));
+  TEST_CASE("split forwards errors", "[adaptors][split]")
+  {
+    SECTION("of exception_ptr type")
+    {
+      auto split    = exec::split(ex::just_error(std::exception_ptr{}));
       using split_t = decltype(split);
       using error_t = ex::error_types_of_t<split_t, ex::env<>, ex::__mmake_set>;
-      static_assert(ex::__mset_eq<error_t, ex::__mset<const std::exception_ptr&>>);
+      static_assert(ex::__mset_eq<error_t, ex::__mset<std::exception_ptr const &>>);
 
       auto op = ex::connect(split, expect_error_receiver{});
       ex::start(op);
       // The receiver will ensure that the right value is produced
     }
 
-    SECTION("of any type") {
-      auto split = exec::split(ex::just_error(42));
+    SECTION("of any type")
+    {
+      auto split    = exec::split(ex::just_error(42));
       using split_t = decltype(split);
       using error_t = ex::error_types_of_t<split_t, ex::env<>, ex::__mmake_set>;
-      static_assert(ex::__mset_eq<error_t, ex::__mset<const std::exception_ptr&, const int&>>);
+      static_assert(ex::__mset_eq<error_t, ex::__mset<std::exception_ptr const &, int const &>>);
 
       auto op = ex::connect(split, expect_error_receiver<int>{});
       ex::start(op);
     }
   }
 
-  TEST_CASE("split forwards stop signal", "[adaptors][split]") {
-    auto split = exec::split(ex::just_stopped());
+  TEST_CASE("split forwards stop signal", "[adaptors][split]")
+  {
+    auto split    = exec::split(ex::just_stopped());
     using split_t = decltype(split);
     static_assert(ex::sends_stopped<split_t, ex::env<>>);
 
@@ -137,21 +155,21 @@ namespace {
     // The receiver will ensure that the right value is produced
   }
 
-  TEST_CASE("split forwards external stop signal (1)", "[adaptors][split]") {
+  TEST_CASE("split forwards external stop signal (1)", "[adaptors][split]")
+  {
     ex::inplace_stop_source ssource;
-    bool called = false;
-    int counter{};
-    auto split = exec::split(ex::just() | ex::then([&] { called = true; }));
-    auto sndr = ex::write_env(
-      ex::upon_stopped(
-        std::move(split),
-        [&] {
-          ++counter;
-          return 42;
-        }),
-      ex::prop{ex::get_stop_token, ssource.get_token()});
-    auto op1 = ex::connect(sndr, expect_value_receiver{42});
-    auto op2 = ex::connect(std::move(sndr), expect_value_receiver{42});
+    bool                    called = false;
+    int                     counter{};
+    auto                    split = exec::split(ex::just() | ex::then([&] { called = true; }));
+    auto                    sndr  = ex::write_env(ex::upon_stopped(std::move(split),
+                                               [&]
+                                               {
+                                                 ++counter;
+                                                 return 42;
+                                               }),
+                              ex::prop{ex::get_stop_token, ssource.get_token()});
+    auto                    op1   = ex::connect(sndr, expect_value_receiver{42});
+    auto                    op2   = ex::connect(std::move(sndr), expect_value_receiver{42});
     ssource.request_stop();
     CHECK(counter == 0);
     ex::start(op1);
@@ -162,263 +180,298 @@ namespace {
     CHECK(!called);
   }
 
-  TEST_CASE("split forwards external stop signal (2)", "[adaptors][split]") {
+  TEST_CASE("split forwards external stop signal (2)", "[adaptors][split]")
+  {
     ex::inplace_stop_source ssource;
-    bool called = false;
-    int counter{};
-    auto split = exec::split(ex::just() | ex::then([&] {
-                             called = true;
-                             return 7;
-                           }));
-    auto sndr = ex::write_env(
-      ex::upon_stopped(
-        std::move(split),
-        [&] {
-          ++counter;
-          return 42;
-        }),
-      ex::prop{ex::get_stop_token, ssource.get_token()});
-    auto op1 = ex::connect(sndr, expect_value_receiver{7});
-    auto op2 = ex::connect(sndr, expect_value_receiver{42});
+    bool                    called = false;
+    int                     counter{};
+    auto                    split = exec::split(ex::just()
+                             | ex::then(
+                               [&]
+                               {
+                                 called = true;
+                                 return 7;
+                               }));
+    auto                    sndr  = ex::write_env(ex::upon_stopped(std::move(split),
+                                               [&]
+                                               {
+                                                 ++counter;
+                                                 return 42;
+                                               }),
+                              ex::prop{ex::get_stop_token, ssource.get_token()});
+    auto                    op1   = ex::connect(sndr, expect_value_receiver{7});
+    auto                    op2   = ex::connect(sndr, expect_value_receiver{42});
     REQUIRE(counter == 0);
-    ex::start(op1); // operation starts and finishes.
+    ex::start(op1);  // operation starts and finishes.
     REQUIRE(counter == 0);
     REQUIRE(called);
     ssource.request_stop();
-    ex::start(op2); // operation completes immediately with stopped.
+    ex::start(op2);  // operation completes immediately with stopped.
     REQUIRE(counter == 1);
   }
 
-  TEST_CASE("split forwards external stop signal (3)", "[adaptors][split]") {
-    impulse_scheduler sched;
+  TEST_CASE("split forwards external stop signal (3)", "[adaptors][split]")
+  {
+    impulse_scheduler       sched;
     ex::inplace_stop_source ssource;
-    bool called = false;
-    int counter{};
-    auto split = exec::split(ex::starts_on(sched, ex::just() | ex::then([&] {
-                                                  called = true;
-                                                  return 7;
-                                                })));
-    auto sndr = ex::write_env(
-      ex::upon_stopped(
-        std::move(split),
-        [&] {
-          ++counter;
-          return 42;
-        }),
-      ex::prop{ex::get_stop_token, ssource.get_token()});
-    auto op1 = ex::connect(sndr, expect_value_receiver{42});
-    auto op2 = ex::connect(std::move(sndr), expect_value_receiver{42});
+    bool                    called = false;
+    int                     counter{};
+    auto                    split = exec::split(ex::starts_on(sched,
+                                           ex::just()
+                                             | ex::then(
+                                               [&]
+                                               {
+                                                 called = true;
+                                                 return 7;
+                                               })));
+    auto                    sndr  = ex::write_env(ex::upon_stopped(std::move(split),
+                                               [&]
+                                               {
+                                                 ++counter;
+                                                 return 42;
+                                               }),
+                              ex::prop{ex::get_stop_token, ssource.get_token()});
+    auto                    op1   = ex::connect(sndr, expect_value_receiver{42});
+    auto                    op2   = ex::connect(std::move(sndr), expect_value_receiver{42});
     REQUIRE(counter == 0);
-    ex::start(op1); // puts a unit of work on the impulse_scheduler and
-                    // op1 into the list of waiting operations.
+    ex::start(op1);  // puts a unit of work on the impulse_scheduler and
+                     // op1 into the list of waiting operations.
     REQUIRE(counter == 0);
     REQUIRE(!called);
-    ssource.request_stop(); // This executes op1's stop callback, which
-                            // completes op1 with "stopped". counter == 1
+    ssource.request_stop();  // This executes op1's stop callback, which
+                             // completes op1 with "stopped". counter == 1
     REQUIRE(counter == 1);
-    ex::start(op2); // Should immediately call set_stopped without getting
-                    // added to the list of waiting operations. counter == 2
+    ex::start(op2);  // Should immediately call set_stopped without getting
+                     // added to the list of waiting operations. counter == 2
     REQUIRE(counter == 2);
     REQUIRE(!called);
-    sched.start_next(); // Impulse scheduler notices stop has been requested
-                        // and completes the underlying operation (just | then(...))
-                        // with "stopped".
+    sched.start_next();  // Impulse scheduler notices stop has been requested
+                         // and completes the underlying operation (just | then(...))
+                         // with "stopped".
     REQUIRE(counter == 2);
     REQUIRE(!called);
   }
 
-  TEST_CASE("split forwards external stop signal (4)", "[adaptors][split]") {
-    impulse_scheduler sched;
+  TEST_CASE("split forwards external stop signal (4)", "[adaptors][split]")
+  {
+    impulse_scheduler       sched;
     ex::inplace_stop_source ssource;
-    bool called = false;
-    int counter{};
-    auto split = exec::split(ex::just() | ex::then([&] {
-                             called = true;
-                             return 7;
-                           }));
-    auto sndr1 = ex::starts_on(
+    bool                    called = false;
+    int                     counter{};
+    auto                    split = exec::split(ex::just()
+                             | ex::then(
+                               [&]
+                               {
+                                 called = true;
+                                 return 7;
+                               }));
+    auto                    sndr1 = ex::starts_on(
       sched,
-      ex::upon_stopped(
-        ex::write_env(split, ex::prop{ex::get_stop_token, ssource.get_token()}), [&] {
-          ++counter;
-          return 42;
-        }));
-    auto sndr2 = ex::write_env(
-      ex::starts_on(
-        sched,
-        ex::upon_stopped(
-          std::move(split),
-          [&] {
-            ++counter;
-            return 42;
-          })),
-      ex::prop{ex::get_stop_token, ssource.get_token()});
-    auto op1 = ex::connect(std::move(sndr1), expect_value_receiver{7});
-    auto op2 = ex::connect(std::move(sndr2), expect_stopped_receiver{});
+      ex::upon_stopped(ex::write_env(split, ex::prop{ex::get_stop_token, ssource.get_token()}),
+                       [&]
+                       {
+                         ++counter;
+                         return 42;
+                       }));
+    auto sndr2 = ex::write_env(ex::starts_on(sched,
+                                             ex::upon_stopped(std::move(split),
+                                                              [&]
+                                                              {
+                                                                ++counter;
+                                                                return 42;
+                                                              })),
+                               ex::prop{ex::get_stop_token, ssource.get_token()});
+    auto op1   = ex::connect(std::move(sndr1), expect_value_receiver{7});
+    auto op2   = ex::connect(std::move(sndr2), expect_stopped_receiver{});
     REQUIRE(counter == 0);
-    ex::start(op1); // puts a unit of work on the impulse_scheduler.
+    ex::start(op1);  // puts a unit of work on the impulse_scheduler.
     REQUIRE(counter == 0);
     REQUIRE(!called);
-    sched.start_next(); // Impulse scheduler starts split sender, which
-                        // completes with 7.
+    sched.start_next();  // Impulse scheduler starts split sender, which
+                         // completes with 7.
     REQUIRE(counter == 0);
     REQUIRE(called);
-    ex::start(op2); // puts another unit of work on the impulse_scheduler
+    ex::start(op2);  // puts another unit of work on the impulse_scheduler
     REQUIRE(counter == 0);
     ssource.request_stop();
-    sched.start_next(); // Impulse scheduler notices stop has been
-                        // requested and "stops" the work.
+    sched.start_next();  // Impulse scheduler notices stop has been
+                         // requested and "stops" the work.
     REQUIRE(counter == 0);
   }
 
-  TEST_CASE("split forwards results from a different thread", "[adaptors][split]") {
+  TEST_CASE("split forwards results from a different thread", "[adaptors][split]")
+  {
     exec::static_thread_pool pool{1};
-    auto split = ex::schedule(pool.get_scheduler()) | ex::then([] {
-                   std::this_thread::sleep_for(1ms);
-                   return 42;
-                 })
+    auto                     split = ex::schedule(pool.get_scheduler())
+               | ex::then(
+                   []
+                   {
+                     std::this_thread::sleep_for(1ms);
+                     return 42;
+                   })
                | exec::split();
 
     auto [val] = ex::sync_wait(split).value();
     REQUIRE(val == 42);
   }
 
-  TEST_CASE("split is thread-safe", "[adaptors][split]") {
+  TEST_CASE("split is thread-safe", "[adaptors][split]")
+  {
     exec::static_thread_pool pool{1};
 
-    std::mt19937_64 eng{std::random_device{}()}; // or seed however you want
+    std::mt19937_64                 eng{std::random_device{}()};  // or seed however you want
     std::uniform_int_distribution<> dist{0, 1000};
 
     auto split = ex::just(std::chrono::microseconds{dist(eng)})
                | ex::continues_on(pool.get_scheduler())
-               | ex::then([](std::chrono::microseconds delay) {
-                   std::this_thread::sleep_for(delay);
-                   return 42;
-                 })
+               | ex::then(
+                   [](std::chrono::microseconds delay)
+                   {
+                     std::this_thread::sleep_for(delay);
+                     return 42;
+                   })
                | exec::split();
 
-    const unsigned n_threads = std::thread::hardware_concurrency();
-    std::vector<std::thread> threads(n_threads);
-    std::vector<int> thread_results(n_threads, 0);
-    const std::vector<std::chrono::microseconds> delays = [&] {
+    unsigned const                               n_threads = std::thread::hardware_concurrency();
+    std::vector<std::thread>                     threads(n_threads);
+    std::vector<int>                             thread_results(n_threads, 0);
+    std::vector<std::chrono::microseconds> const delays = [&]
+    {
       std::vector<std::chrono::microseconds> thread_delay(n_threads);
-      for (unsigned tid = 0; tid < n_threads; tid++) {
+      for (unsigned tid = 0; tid < n_threads; tid++)
+      {
         thread_delay[tid] = std::chrono::microseconds{dist(eng)};
       }
       return thread_delay;
     }();
-    for (unsigned tid = 0; tid < n_threads; tid++) {
-      threads[tid] = std::thread([&split, &delays, &thread_results, tid] {
-        inline_scheduler scheduler{};
-
-        std::this_thread::sleep_for(delays[tid]);
-        auto [val] = ex::sync_wait(
-                       split | ex::continues_on(scheduler) | ex::then([](int v) { return v; }))
-                       .value();
-        thread_results[tid] = val;
-      });
+    for (unsigned tid = 0; tid < n_threads; tid++)
+    {
+      threads[tid] = std::thread(
+        [&split, &delays, &thread_results, tid]
+        {
+          inline_scheduler scheduler{};
+
+          std::this_thread::sleep_for(delays[tid]);
+          auto [val] = ex::sync_wait(split | ex::continues_on(scheduler)
+                                     | ex::then([](int v) { return v; }))
+                         .value();
+          thread_results[tid] = val;
+        });
     }
-    for (unsigned tid = 0; tid < n_threads; tid++) {
+    for (unsigned tid = 0; tid < n_threads; tid++)
+    {
       threads[tid].join();
       REQUIRE(thread_results[tid] == 42);
     }
   }
 
-  TEST_CASE("split can be an rvalue", "[adaptors][split]") {
-    auto [val] = ex::sync_wait(ex::just(42) | exec::split() | ex::then([](int v) { return v; }))
-                   .value();
+  TEST_CASE("split can be an rvalue", "[adaptors][split]")
+  {
+    auto [val] =
+      ex::sync_wait(ex::just(42) | exec::split() | ex::then([](int v) { return v; })).value();
 
     REQUIRE(val == 42);
   }
 
-  struct move_only_type {
+  struct move_only_type
+  {
     move_only_type()
-      : val(0) {
-    }
+      : val(0)
+    {}
 
     move_only_type(int v)
-      : val(v) {
-    }
+      : val(v)
+    {}
 
-    move_only_type(move_only_type&&) = default;
+    move_only_type(move_only_type &&) = default;
     int val;
   };
 
-  struct copy_and_movable_type {
+  struct copy_and_movable_type
+  {
     copy_and_movable_type(int v)
-      : val(v) {
-    }
+      : val(v)
+    {}
 
     int val;
   };
 
-  TEST_CASE("split into then", "[adaptors][split]") {
-    SECTION("split with move only input sender of temporary") {
-      auto snd = exec::split(ex::just(move_only_type{0})) | ex::then([](const move_only_type&) { });
+  TEST_CASE("split into then", "[adaptors][split]")
+  {
+    SECTION("split with move only input sender of temporary")
+    {
+      auto snd = exec::split(ex::just(move_only_type{0})) | ex::then([](move_only_type const &) {});
       ex::sync_wait(std::move(snd));
     }
 
-    SECTION("split with move only input sender by moving in") {
+    SECTION("split with move only input sender by moving in")
+    {
       auto snd0 = ex::just(move_only_type{});
-      auto snd = exec::split(std::move(snd0)) | ex::then([](const move_only_type&) { });
+      auto snd  = exec::split(std::move(snd0)) | ex::then([](move_only_type const &) {});
       ex::sync_wait(snd);
     }
 
-    SECTION("split with copyable rvalue input sender") {
+    SECTION("split with copyable rvalue input sender")
+    {
       auto snd = exec::split(ex::just(copy_and_movable_type{0}))
-               | ex::then([](const copy_and_movable_type&) { });
+               | ex::then([](copy_and_movable_type const &) {});
       ex::sync_wait(snd);
     }
 
-    SECTION("split with copyable lvalue input sender") {
+    SECTION("split with copyable lvalue input sender")
+    {
       auto snd0 = ex::just(copy_and_movable_type{0});
-      auto snd = exec::split(snd0) | ex::then([](const copy_and_movable_type&) { });
+      auto snd  = exec::split(snd0) | ex::then([](copy_and_movable_type const &) {});
       ex::sync_wait(snd);
     }
 
-    SECTION("lvalue split move only sender") {
+    SECTION("lvalue split move only sender")
+    {
       auto multishot = exec::split(ex::just(move_only_type{0}));
-      auto snd = multishot | ex::then([](const move_only_type&) { });
+      auto snd       = multishot | ex::then([](move_only_type const &) {});
 
-      REQUIRE(ex::sender_of<decltype(multishot), ex::set_value_t(const move_only_type&)>);
+      REQUIRE(ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type const &)>);
       REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type&)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type&&)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type &)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(move_only_type &&)>);
 
       ex::sync_wait(snd);
     }
 
-    SECTION("lvalue split copyable sender") {
+    SECTION("lvalue split copyable sender")
+    {
       auto multishot = exec::split(ex::just(copy_and_movable_type{0}));
       (void) ex::get_completion_signatures(multishot, ex::env<>{});
-      auto snd = multishot | ex::then([](const copy_and_movable_type&) { });
+      auto snd = multishot | ex::then([](copy_and_movable_type const &) {});
 
       REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(const copy_and_movable_type)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type&)>);
-      REQUIRE(ex::sender_of<decltype(multishot), ex::set_value_t(const copy_and_movable_type&)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type&&)>);
-      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(const copy_and_movable_type&&)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type const)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type &)>);
+      REQUIRE(ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type const &)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type &&)>);
+      REQUIRE(!ex::sender_of<decltype(multishot), ex::set_value_t(copy_and_movable_type const &&)>);
 
       ex::sync_wait(snd);
     }
   }
 
-  TEMPLATE_TEST_CASE(
-    "split move-only and copyable senders",
-    "[adaptors][split]",
-    move_only_type,
-    copy_and_movable_type) {
-    int called = 0;
-    auto multishot = ex::just(TestType(10)) | ex::then([&](TestType obj) {
-                       ++called;
-                       return TestType(obj.val + 1);
-                     })
+  TEMPLATE_TEST_CASE("split move-only and copyable senders",
+                     "[adaptors][split]",
+                     move_only_type,
+                     copy_and_movable_type)
+  {
+    int  called    = 0;
+    auto multishot = ex::just(TestType(10))
+                   | ex::then(
+                       [&](TestType obj)
+                       {
+                         ++called;
+                         return TestType(obj.val + 1);
+                       })
                    | exec::split();
-    auto wa = ex::when_all(
-      ex::then(multishot, [](const TestType& obj) { return obj.val; }),
-      ex::then(multishot, [](const TestType& obj) { return obj.val * 2; }),
-      ex::then(multishot, [](const TestType& obj) { return obj.val * 3; }));
+    auto wa = ex::when_all(ex::then(multishot, [](TestType const &obj) { return obj.val; }),
+                           ex::then(multishot, [](TestType const &obj) { return obj.val * 2; }),
+                           ex::then(multishot, [](TestType const &obj) { return obj.val * 3; }));
 
     auto [v1, v2, v3] = ex::sync_wait(std::move(wa)).value();
 
@@ -431,20 +484,24 @@ namespace {
   template <class T>
   concept can_split_lvalue_of = requires(T t) { exec::split(t); };
 
-  TEST_CASE("split can only accept copyable lvalue input senders", "[adaptors][split]") {
+  TEST_CASE("split can only accept copyable lvalue input senders", "[adaptors][split]")
+  {
     static_assert(!can_split_lvalue_of<decltype(ex::just(move_only_type{0}))>);
     static_assert(can_split_lvalue_of<decltype(ex::just(copy_and_movable_type{0}))>);
   }
 
-  TEST_CASE("split into when_all", "[adaptors][split]") {
-    int counter{};
-    auto snd = exec::split(ex::just() | ex::then([&] {
-                           counter++;
-                           return counter;
-                         }));
-    auto wa = ex::when_all(snd | ex::then([](auto) { return 10; }), snd | ex::then([](auto) {
-                                                                      return 20;
-                                                                    }));
+  TEST_CASE("split into when_all", "[adaptors][split]")
+  {
+    int  counter{};
+    auto snd = exec::split(ex::just()
+                           | ex::then(
+                             [&]
+                             {
+                               counter++;
+                               return counter;
+                             }));
+    auto wa  = ex::when_all(snd | ex::then([](auto) { return 10; }),
+                           snd | ex::then([](auto) { return 20; }));
     REQUIRE(counter == 0);
     auto [v1, v2] = ex::sync_wait(std::move(wa)).value();
     REQUIRE(counter == 1);
@@ -452,20 +509,27 @@ namespace {
     REQUIRE(v2 == 20);
   }
 
-  TEST_CASE("split can nest", "[adaptors][split]") {
+  TEST_CASE("split can nest", "[adaptors][split]")
+  {
     auto split_1 = ex::just(42) | exec::split();
     auto split_2 = split_1 | exec::split();
 
-    auto [v1] = ex::sync_wait(split_1 | ex::then([](const int& cv) {
-                                int& v = const_cast<int&>(cv);
-                                return v = 1;
-                              }))
+    auto [v1] = ex::sync_wait(split_1
+                              | ex::then(
+                                [](int const &cv)
+                                {
+                                  int &v   = const_cast<int &>(cv);
+                                  return v = 1;
+                                }))
                   .value();
 
-    auto [v2] = ex::sync_wait(split_2 | ex::then([](const int& cv) {
-                                int& v = const_cast<int&>(cv);
-                                return v = 2;
-                              }))
+    auto [v2] = ex::sync_wait(split_2
+                              | ex::then(
+                                [](int const &cv)
+                                {
+                                  int &v   = const_cast<int &>(cv);
+                                  return v = 2;
+                                }))
                   .value();
 
     auto [v3] = ex::sync_wait(split_1).value();
@@ -475,10 +539,11 @@ namespace {
     REQUIRE(v3 == 1);
   }
 
-  TEST_CASE("split doesn't advertise completion scheduler", "[adaptors][split]") {
+  TEST_CASE("split doesn't advertise completion scheduler", "[adaptors][split]")
+  {
     inline_scheduler sched;
 
-    auto snd = ex::just(42) | ex::continues_on(sched) | exec::split();
+    auto snd    = ex::just(42) | ex::continues_on(sched) | exec::split();
     using snd_t = decltype(snd);
     static_assert(!ex::__callable<ex::get_completion_scheduler_t<ex::set_value_t>, snd_t>);
     static_assert(!ex::__callable<ex::get_completion_scheduler_t<ex::set_error_t>, snd_t>);
@@ -486,19 +551,22 @@ namespace {
     (void) snd;
   }
 
-  struct my_sender {
+  struct my_sender
+  {
     using sender_concept = ex::sender_t;
-    using is_sender = void;
+    using is_sender      = void;
 
     using completion_signatures = ex::completion_signatures_of_t<decltype(ex::just())>;
 
     template <class Recv>
-    auto connect(Recv&& recv) const {
+    auto connect(Recv &&recv) const
+    {
       return ex::connect(ex::just(), std::forward<Recv>(recv));
     }
   };
 
-  TEST_CASE("split accepts a custom sender", "[adaptors][split]") {
+  TEST_CASE("split accepts a custom sender", "[adaptors][split]")
+  {
     auto snd1 = my_sender();
     auto snd2 = exec::split(std::move(snd1));
     static_assert(ex::__well_formed_sender<decltype(snd1)>);
@@ -511,4 +579,4 @@ namespace {
     (void) snd2;
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/test_start_detached.cpp b/test/exec/test_start_detached.cpp
index 86e32dad5..aee370b5a 100644
--- a/test/exec/test_start_detached.cpp
+++ b/test/exec/test_start_detached.cpp
@@ -23,7 +23,7 @@
 
 #include <catch2/catch.hpp>
 
-#include <chrono> // IWYU pragma: keep for std::chrono_literals
+#include <chrono>  // IWYU pragma: keep for std::chrono_literals
 
 #if STDEXEC_HAS_STD_MEMORY_RESOURCE()
 #  include <memory_resource>
@@ -37,36 +37,40 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-namespace {
+namespace
+{
 
-  TEST_CASE("start_detached simple test", "[consumers][start_detached]") {
+  TEST_CASE("start_detached simple test", "[consumers][start_detached]")
+  {
     bool called{false};
     exec::start_detached(ex::just() | ex::then([&] { called = true; }));
     CHECK(called);
   }
 
-  TEST_CASE("start_detached works with void senders", "[consumers][start_detached]") {
+  TEST_CASE("start_detached works with void senders", "[consumers][start_detached]")
+  {
     exec::start_detached(ex::just());
   }
 
-  TEST_CASE("start_detached works with multi-value senders", "[consumers][start_detached]") {
+  TEST_CASE("start_detached works with multi-value senders", "[consumers][start_detached]")
+  {
     exec::start_detached(ex::just(3, 0.1415));
   }
 
   // Trying to test `start_detached` with error flows will result in calling `std::terminate()`.
   // We don't want that
 
-  TEST_CASE(
-    "start_detached works with sender ending with `set_stopped`",
-    "[consumers][start_detached]") {
+  TEST_CASE("start_detached works with sender ending with `set_stopped`",
+            "[consumers][start_detached]")
+  {
     exec::start_detached(ex::just_stopped());
   }
 
-  TEST_CASE(
-    "start_detached works with senders that do not complete immediately",
-    "[consumers][start_detached]") {
+  TEST_CASE("start_detached works with senders that do not complete immediately",
+            "[consumers][start_detached]")
+  {
     impulse_scheduler sched;
-    bool called{false};
+    bool              called{false};
     // Start the sender
     exec::start_detached(ex::just() | ex::continues_on(sched) | ex::then([&] { called = true; }));
     // The `then` function is not yet called
@@ -76,9 +80,10 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE("start_detached works when changing threads", "[consumers][start_detached]") {
+  TEST_CASE("start_detached works when changing threads", "[consumers][start_detached]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // lunch some work on the thread pool
       ex::sender auto snd = ex::just() | ex::continues_on(pool.get_scheduler())
@@ -94,53 +99,62 @@ namespace {
     REQUIRE(called);
   }
 
-  struct custom_sender {
-    using sender_concept = ex::sender_t;
+  struct custom_sender
+  {
+    using sender_concept        = ex::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
     bool* called;
 
-    struct domain {
+    struct domain
+    {
       template <class Sender, class... Env>
-      static void apply_sender(exec::start_detached_t, Sender self, Env&&...) {
+      static void apply_sender(exec::start_detached_t, Sender self, Env&&...)
+      {
         *self.called = true;
       }
     };
 
-    struct noop {
-      void start() & noexcept {
-      }
+    struct noop
+    {
+      void start() & noexcept {}
     };
 
     [[nodiscard]]
-    auto get_env() const noexcept {
+    auto get_env() const noexcept
+    {
       return ex::prop{ex::get_completion_domain<ex::set_value_t>, domain{}};
     }
 
     template <class Receiver>
-    auto connect(Receiver&&) const -> noop {
+    auto connect(Receiver&&) const -> noop
+    {
       static_assert(sizeof(Receiver) == 0);
       FAIL("this should not be called");
       return noop{};
     }
   };
 
-  struct custom_scheduler {
-    struct sender {
-      using sender_concept = ex::sender_t;
+  struct custom_scheduler
+  {
+    struct sender
+    {
+      using sender_concept        = ex::sender_t;
       using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
       [[nodiscard]]
-      auto get_env() const noexcept {
+      auto get_env() const noexcept
+      {
         return ex::prop{ex::get_completion_scheduler<ex::set_value_t>, custom_scheduler{called}};
       }
 
-      struct noop {
-        void start() & noexcept {
-        }
+      struct noop
+      {
+        void start() & noexcept {}
       };
 
       template <class Receiver>
-      auto connect(Receiver&&) const {
+      auto connect(Receiver&&) const
+      {
         FAIL("this should not be called");
         return noop{};
       }
@@ -148,50 +162,58 @@ namespace {
       bool* called{};
     };
 
-    struct domain {
+    struct domain
+    {
       template <class Sender, class Env>
-      void apply_sender(exec::start_detached_t, Sender, const Env& env) const {
+      void apply_sender(exec::start_detached_t, Sender, Env const & env) const
+      {
         custom_scheduler sched = ex::get_scheduler(env);
-        *sched.called = true;
+        *sched.called          = true;
       }
     };
 
     [[nodiscard]]
-    auto query(ex::get_domain_t) const noexcept -> domain {
+    auto query(ex::get_domain_t) const noexcept -> domain
+    {
       return {};
     }
 
     template <ex::__completion_tag Tag>
     [[nodiscard]]
-    auto query(ex::get_completion_scheduler_t<Tag>, ex::__ignore = {}) const noexcept
-      -> custom_scheduler {
+    auto
+    query(ex::get_completion_scheduler_t<Tag>, ex::__ignore = {}) const noexcept -> custom_scheduler
+    {
       return *this;
     }
 
     template <ex::__completion_tag Tag>
     [[nodiscard]]
-    auto query(ex::get_completion_domain_t<Tag>, ex::__ignore = {}) const noexcept -> domain {
+    auto query(ex::get_completion_domain_t<Tag>, ex::__ignore = {}) const noexcept -> domain
+    {
       return {};
     }
 
     [[nodiscard]]
-    auto schedule() const noexcept -> sender {
+    auto schedule() const noexcept -> sender
+    {
       return {};
     }
 
-    auto operator==(const custom_scheduler&) const -> bool = default;
+    auto operator==(custom_scheduler const &) const -> bool = default;
 
     bool* called{};
   };
 
-  TEST_CASE("start_detached can be customized on sender", "[consumers][start_detached]") {
+  TEST_CASE("start_detached can be customized on sender", "[consumers][start_detached]")
+  {
     bool called = false;
     exec::start_detached(custom_sender{&called});
     CHECK(called);
   }
 
   // NOT TO SPEC
-  TEST_CASE("start_detached can be customized on scheduler", "[consumers][start_detached]") {
+  TEST_CASE("start_detached can be customized on scheduler", "[consumers][start_detached]")
+  {
     bool called = false;
     exec::start_detached(ex::just(), ex::prop{ex::get_scheduler, custom_scheduler{&called}});
     CHECK(called);
@@ -200,32 +222,38 @@ namespace {
 #if STDEXEC_HAS_STD_MEMORY_RESOURCE()                                                              \
   && (defined(__cpp_lib_polymorphic_allocator) && __cpp_lib_polymorphic_allocator >= 2019'02L)
 
-  struct counting_resource : std::pmr::memory_resource {
+  struct counting_resource : std::pmr::memory_resource
+  {
     counting_resource() = default;
 
     [[nodiscard]]
-    auto get_count() const noexcept -> std::size_t {
+    auto get_count() const noexcept -> std::size_t
+    {
       return count;
     }
 
     [[nodiscard]]
-    auto get_alive() const noexcept -> std::size_t {
+    auto get_alive() const noexcept -> std::size_t
+    {
       return alive;
     }
    private:
-    auto do_allocate(std::size_t bytes, std::size_t alignment) -> void* override {
+    auto do_allocate(std::size_t bytes, std::size_t alignment) -> void* override
+    {
       ++count;
       ++alive;
       return std::pmr::new_delete_resource()->allocate(bytes, alignment);
     }
 
-    void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override {
+    void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override
+    {
       --alive;
       return std::pmr::new_delete_resource()->deallocate(p, bytes, alignment);
     }
 
     [[nodiscard]]
-    auto do_is_equal(const memory_resource& other) const noexcept -> bool override {
+    auto do_is_equal(memory_resource const & other) const noexcept -> bool override
+    {
       return this == &other;
     }
 
@@ -233,43 +261,53 @@ namespace {
   };
 
   // NOT TO SPEC
-  TEST_CASE("start_detached works with a custom allocator", "[consumers][start_detached]") {
-    bool called = false;
-    counting_resource res;
+  TEST_CASE("start_detached works with a custom allocator", "[consumers][start_detached]")
+  {
+    bool                                       called = false;
+    counting_resource                          res;
     std::pmr::polymorphic_allocator<std::byte> alloc(&res);
-    exec::start_detached(
-      ex::just() | ex::then([&] { called = true; }), ex::prop{ex::get_allocator, alloc});
+    exec::start_detached(ex::just() | ex::then([&] { called = true; }),
+                         ex::prop{ex::get_allocator, alloc});
     CHECK(called);
     CHECK(res.get_count() == 1);
     CHECK(res.get_alive() == 0);
   }
 #endif
 
-  TEST_CASE("ex::on can be passed to start_detached", "[adaptors][ex::on]") {
+  TEST_CASE("ex::on can be passed to start_detached", "[adaptors][ex::on]")
+  {
     ex::run_loop loop;
-    auto sch = loop.get_scheduler();
-    auto snd = ex::get_scheduler() | ex::let_value([](auto sched) {
-                 static_assert(std::same_as<decltype(sched), ex::run_loop::scheduler>);
-                 return ex::starts_on(sched, ex::just());
-               });
+    auto         sch = loop.get_scheduler();
+    auto         snd = ex::get_scheduler()
+             | ex::let_value(
+                 [](auto sched)
+                 {
+                   static_assert(std::same_as<decltype(sched), ex::run_loop::scheduler>);
+                   return ex::starts_on(sched, ex::just());
+                 });
     exec::start_detached(ex::on(sch, std::move(snd)));
     loop.finish();
     loop.run();
   }
 
-  struct env { };
+  struct env
+  {};
 
-  TEST_CASE("ex::on can be passed to start_detached with env", "[adaptors][ex::on]") {
+  TEST_CASE("ex::on can be passed to start_detached with env", "[adaptors][ex::on]")
+  {
     ex::run_loop loop;
-    auto sch = loop.get_scheduler();
-    auto snd = ex::get_scheduler() | ex::let_value([](auto sched) {
-                 static_assert(std::same_as<decltype(sched), ex::run_loop::scheduler>);
-                 return ex::starts_on(sched, ex::just());
-               });
+    auto         sch = loop.get_scheduler();
+    auto         snd = ex::get_scheduler()
+             | ex::let_value(
+                 [](auto sched)
+                 {
+                   static_assert(std::same_as<decltype(sched), ex::run_loop::scheduler>);
+                   return ex::starts_on(sched, ex::just());
+                 });
     exec::start_detached(ex::on(sch, std::move(snd)), env{});
     loop.finish();
     loop.run();
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/exec/test_static_thread_pool.cpp b/test/exec/test_static_thread_pool.cpp
index 277fce0d4..cca5f83a9 100644
--- a/test/exec/test_static_thread_pool.cpp
+++ b/test/exec/test_static_thread_pool.cpp
@@ -7,14 +7,15 @@
 #include <unordered_set>
 namespace ex = STDEXEC;
 
-TEST_CASE(
-  "static_thread_pool::get_scheduler_on_thread Test start on a specific thread",
-  "[types][static_thread_pool]") {
-  constexpr const size_t num_of_threads = 5;
+TEST_CASE("static_thread_pool::get_scheduler_on_thread Test start on a specific thread",
+          "[types][static_thread_pool]")
+{
+  constexpr size_t const   num_of_threads = 5;
   exec::static_thread_pool pool{num_of_threads};
 
   std::unordered_set<std::thread::id> thread_ids;
-  for (size_t i = 0; i < num_of_threads; ++i) {
+  for (size_t i = 0; i < num_of_threads; ++i)
+  {
     auto sender = ex::schedule(pool.get_scheduler_on_thread(i))
                 | ex::then([&]() -> void { thread_ids.insert(std::this_thread::get_id()); });
     ex::sync_wait(std::move(sender));
@@ -22,38 +23,45 @@ TEST_CASE(
   REQUIRE(thread_ids.size() == num_of_threads);
 }
 
-TEST_CASE(
-  "bulk on static_thread_pool executes on multiple threads",
-  "[types][static_thread_pool]") {
-  constexpr const size_t num_of_threads = 5;
+TEST_CASE("bulk on static_thread_pool executes on multiple threads", "[types][static_thread_pool]")
+{
+  constexpr size_t const   num_of_threads = 5;
   exec::static_thread_pool pool{num_of_threads};
 
-  std::mutex mtx;
+  std::mutex                          mtx;
   std::unordered_set<std::thread::id> thread_ids;
-  auto sender = ex::starts_on(
-    pool.get_scheduler(), ex::just() | ex::bulk(ex::par_unseq, num_of_threads, [&](size_t) -> void {
-                            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-                            std::lock_guard lock(mtx);
-                            thread_ids.insert(std::this_thread::get_id());
-                          }));
+  auto                                sender = ex::starts_on(pool.get_scheduler(),
+                              ex::just()
+                                | ex::bulk(ex::par_unseq,
+                                           num_of_threads,
+                                           [&](size_t) -> void
+                                           {
+                                             std::this_thread::sleep_for(
+                                               std::chrono::milliseconds(100));
+                                             std::lock_guard lock(mtx);
+                                             thread_ids.insert(std::this_thread::get_id());
+                                           }));
   ex::sync_wait(std::move(sender));
   REQUIRE(thread_ids.size() == num_of_threads);
 }
 
-TEST_CASE(
-  "bulk on static_thread_pool executes on multiple threads, take 2",
-  "[types][static_thread_pool]") {
-  constexpr const size_t num_of_threads = 5;
+TEST_CASE("bulk on static_thread_pool executes on multiple threads, take 2",
+          "[types][static_thread_pool]")
+{
+  constexpr size_t const   num_of_threads = 5;
   exec::static_thread_pool pool{num_of_threads};
 
-  std::mutex mtx;
+  std::mutex                          mtx;
   std::unordered_set<std::thread::id> thread_ids;
-  auto sender = ex::schedule(pool.get_scheduler())
-              | ex::bulk(ex::par_unseq, num_of_threads, [&](size_t) -> void {
-                  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-                  std::lock_guard lock(mtx);
-                  thread_ids.insert(std::this_thread::get_id());
-                });
+  auto                                sender = ex::schedule(pool.get_scheduler())
+              | ex::bulk(ex::par_unseq,
+                         num_of_threads,
+                         [&](size_t) -> void
+                         {
+                           std::this_thread::sleep_for(std::chrono::milliseconds(100));
+                           std::lock_guard lock(mtx);
+                           thread_ids.insert(std::this_thread::get_id());
+                         });
   ex::sync_wait(std::move(sender));
   REQUIRE(thread_ids.size() == num_of_threads);
 }
diff --git a/test/exec/test_task.cpp b/test/exec/test_task.cpp
index f29e2f797..ef6596970 100644
--- a/test/exec/test_task.cpp
+++ b/test/exec/test_task.cpp
@@ -31,7 +31,8 @@
 namespace ex = STDEXEC;
 using namespace std::string_literals;
 
-namespace {
+namespace
+{
 
   // This is a work-around for clang-12 bugs in Release mode
   thread_local constinit int thread_id = 0;
@@ -39,115 +40,120 @@ namespace {
   static_assert(STDEXEC::sender<exec::task<void>>);
 
   // This is a work-around for apple clang bugs in Release mode
-  STDEXEC_PP_WHEN(STDEXEC_APPLE_CLANG(), [[clang::optnone]]) auto get_id() -> int {
+  STDEXEC_PP_WHEN(STDEXEC_APPLE_CLANG(), [[clang::optnone]]) auto get_id() -> int
+  {
     return thread_id;
   }
 
-  auto test_stickiness_for_two_single_thread_contexts_nested(
-    ex::scheduler auto scheduler1,
-    ex::scheduler auto,
-    auto id1,
-    auto id2) -> exec::task<void> {
-    CHECK(get_id() == id2);                       // This task is started in context2
-    co_await ex::schedule(scheduler1);                // Try to ex::schedule in context1
-    CHECK(get_id() == id2);                       // But this task is still in context2
-    co_await exec::reschedule_coroutine_on(scheduler1); // Transition to context1
-    CHECK(get_id() == id1);                       // Now we are in context1
-  } // Reschedules back to context2
-
-  auto test_stickiness_for_two_single_thread_contexts_(
-    auto scheduler1,
-    auto scheduler2,
-    auto id1,
-    auto id2) -> exec::task<void> {
-    CHECK(get_id() == id1);        // This task is start in context1
-    co_await ex::schedule(scheduler2); // Try to ex::schedule in context2
-    CHECK(get_id() == id1);        // But this task is still in context1
+  auto test_stickiness_for_two_single_thread_contexts_nested(ex::scheduler auto scheduler1,
+                                                             ex::scheduler auto,
+                                                             auto id1,
+                                                             auto id2) -> exec::task<void>
+  {
+    CHECK(get_id() == id2);                              // This task is started in context2
+    co_await ex::schedule(scheduler1);                   // Try to ex::schedule in context1
+    CHECK(get_id() == id2);                              // But this task is still in context2
+    co_await exec::reschedule_coroutine_on(scheduler1);  // Transition to context1
+    CHECK(get_id() == id1);                              // Now we are in context1
+  }  // Reschedules back to context2
+
+  auto test_stickiness_for_two_single_thread_contexts_(auto scheduler1,
+                                                       auto scheduler2,
+                                                       auto id1,
+                                                       auto id2) -> exec::task<void>
+  {
+    CHECK(get_id() == id1);             // This task is start in context1
+    co_await ex::schedule(scheduler2);  // Try to ex::schedule in context2
+    CHECK(get_id() == id1);             // But this task is still in context1
     co_await (ex::schedule(scheduler1) | ex::then([&] { CHECK(get_id() == id1); }));
     co_await (ex::schedule(scheduler2) | ex::then([&] { CHECK(get_id() == id2); }));
     CHECK(get_id() == id1);
-    co_await exec::reschedule_coroutine_on(scheduler2); // Transition to context2
-    CHECK(get_id() == id2);                       // Now we are in context2
+    co_await exec::reschedule_coroutine_on(scheduler2);  // Transition to context2
+    CHECK(get_id() == id2);                              // Now we are in context2
     // Child task inherits context2
-    co_await test_stickiness_for_two_single_thread_contexts_nested(
-      scheduler1, scheduler2, id1, id2);
-    CHECK(get_id() == id2); // Child task is done, we are still in context2
-  } // Reschedules back to context1
-
-  auto test_stickiness_for_two_single_thread_contexts_with_sender_(
-    auto scheduler1,
-    auto scheduler2,
-    auto id1,
-    auto id2) -> exec::task<void> {
-    co_await exec::reschedule_coroutine_on(scheduler2); // Transition to context2
-    CHECK(get_id() == id2);                       // Now we are in context2
+    co_await test_stickiness_for_two_single_thread_contexts_nested(scheduler1,
+                                                                   scheduler2,
+                                                                   id1,
+                                                                   id2);
+    CHECK(get_id() == id2);  // Child task is done, we are still in context2
+  }  // Reschedules back to context1
+
+  auto test_stickiness_for_two_single_thread_contexts_with_sender_(auto scheduler1,
+                                                                   auto scheduler2,
+                                                                   auto id1,
+                                                                   auto id2) -> exec::task<void>
+  {
+    co_await exec::reschedule_coroutine_on(scheduler2);  // Transition to context2
+    CHECK(get_id() == id2);                              // Now we are in context2
     // Child task inherits context2
     co_await (
       test_stickiness_for_two_single_thread_contexts_nested(scheduler1, scheduler2, id1, id2)
       | ex::then([&] { CHECK(get_id() == id2); }));
   }
 
-  auto test_stickiness_for_two_single_thread_contexts(
-    auto scheduler1,
-    auto scheduler2,
-    auto id1,
-    auto id2) -> exec::task<void> {
+  auto test_stickiness_for_two_single_thread_contexts(auto scheduler1,
+                                                      auto scheduler2,
+                                                      auto id1,
+                                                      auto id2) -> exec::task<void>
+  {
     co_await exec::reschedule_coroutine_on(scheduler1);
     CHECK(get_id() == id1);
     co_await test_stickiness_for_two_single_thread_contexts_(scheduler1, scheduler2, id1, id2);
     CHECK(get_id() == id1);
   }
 
-  auto test_stickiness_for_two_single_thread_contexts_with_sender(
-    auto scheduler1,
-    auto scheduler2,
-    auto id1,
-    auto id2) -> exec::task<void> {
+  auto test_stickiness_for_two_single_thread_contexts_with_sender(auto scheduler1,
+                                                                  auto scheduler2,
+                                                                  auto id1,
+                                                                  auto id2) -> exec::task<void>
+  {
     co_await exec::reschedule_coroutine_on(scheduler1);
     CHECK(get_id() == id1);
-    co_await test_stickiness_for_two_single_thread_contexts_with_sender_(
-      scheduler1, scheduler2, id1, id2);
+    co_await test_stickiness_for_two_single_thread_contexts_with_sender_(scheduler1,
+                                                                         scheduler2,
+                                                                         id1,
+                                                                         id2);
     CHECK(get_id() == id1);
   }
 
-  TEST_CASE("Test stickiness with two single threads", "[types][sticky][task]") {
+  TEST_CASE("Test stickiness with two single threads", "[types][sticky][task]")
+  {
     exec::single_thread_context context1;
     exec::single_thread_context context2;
-    ex::scheduler auto scheduler1 = context1.get_scheduler();
-    ex::scheduler auto scheduler2 = context2.get_scheduler();
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
+    ex::scheduler auto          scheduler1 = context1.get_scheduler();
+    ex::scheduler auto          scheduler2 = context2.get_scheduler();
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
     auto id1 = 1;
     auto id2 = 2;
-    auto t = test_stickiness_for_two_single_thread_contexts(scheduler1, scheduler2, id1, id2);
+    auto t   = test_stickiness_for_two_single_thread_contexts(scheduler1, scheduler2, id1, id2);
     ex::sync_wait(std::move(t));
   }
 
-  TEST_CASE("Test stickiness with two single threads with on", "[types][sticky][task]") {
+  TEST_CASE("Test stickiness with two single threads with on", "[types][sticky][task]")
+  {
     exec::single_thread_context context1;
     exec::single_thread_context context2;
-    ex::scheduler auto scheduler1 = context1.get_scheduler();
-    ex::scheduler auto scheduler2 = context2.get_scheduler();
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
+    ex::scheduler auto          scheduler1 = context1.get_scheduler();
+    ex::scheduler auto          scheduler2 = context2.get_scheduler();
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
     auto id1 = 1;
     auto id2 = 2;
-    auto t = ex::starts_on(
+    auto t   = ex::starts_on(
       scheduler1,
       test_stickiness_for_two_single_thread_contexts_(scheduler1, scheduler2, id1, id2));
     ex::sync_wait(std::move(t) | ex::then([&] { CHECK(get_id() == id1); }));
   }
 
-  TEST_CASE("Test stickiness with two single threads with sender", "[types][sticky][task]") {
+  TEST_CASE("Test stickiness with two single threads with sender", "[types][sticky][task]")
+  {
     exec::single_thread_context context1;
     exec::single_thread_context context2;
-    ex::scheduler auto scheduler1 = context1.get_scheduler();
-    ex::scheduler auto scheduler2 = context2.get_scheduler();
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
+    ex::scheduler auto          scheduler1 = context1.get_scheduler();
+    ex::scheduler auto          scheduler2 = context2.get_scheduler();
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
     auto id1 = 1;
     auto id2 = 2;
     auto t =
@@ -155,54 +161,54 @@ namespace {
     ex::sync_wait(std::move(t));
   }
 
-  TEST_CASE(
-    "Test stickiness with two single threads with sender with starts_on",
-    "[types][sticky][task]") {
+  TEST_CASE("Test stickiness with two single threads with sender with starts_on",
+            "[types][sticky][task]")
+  {
     exec::single_thread_context context1;
     exec::single_thread_context context2;
-    ex::scheduler auto scheduler1 = context1.get_scheduler();
-    ex::scheduler auto scheduler2 = context2.get_scheduler();
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
+    ex::scheduler auto          scheduler1 = context1.get_scheduler();
+    ex::scheduler auto          scheduler2 = context2.get_scheduler();
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
     auto id1 = 1;
     auto id2 = 2;
-    auto t = ex::starts_on(
-      scheduler1,
-      test_stickiness_for_two_single_thread_contexts_with_sender_(
-        scheduler1, scheduler2, id1, id2));
+    auto t   = ex::starts_on(scheduler1,
+                           test_stickiness_for_two_single_thread_contexts_with_sender_(scheduler1,
+                                                                                       scheduler2,
+                                                                                       id1,
+                                                                                       id2));
     ex::sync_wait(std::move(t) | ex::then([&] { CHECK(get_id() == id1); }));
   }
 
-  TEST_CASE("Use two inline schedulers", "[types][sticky][task]") {
+  TEST_CASE("Use two inline schedulers", "[types][sticky][task]")
+  {
     ex::scheduler auto scheduler1 = STDEXEC::inline_scheduler{};
     ex::scheduler auto scheduler2 = STDEXEC::inline_scheduler{};
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 0; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 0; })));
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 0; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 0; })));
     auto id1 = 0;
     auto id2 = 0;
-    auto t = test_stickiness_for_two_single_thread_contexts(scheduler1, scheduler2, id1, id2);
+    auto t   = test_stickiness_for_two_single_thread_contexts(scheduler1, scheduler2, id1, id2);
     ex::sync_wait(std::move(t));
   }
 
-  auto test_stick_on_main_nested(
-    ex::scheduler auto sched1,
-    ex::scheduler auto,
-    auto id_main_thread,
-    [[maybe_unused]] auto id1,
-    [[maybe_unused]] auto id2) -> exec::task<void> {
+  auto test_stick_on_main_nested(ex::scheduler auto sched1,
+                                 ex::scheduler auto,
+                                 auto                  id_main_thread,
+                                 [[maybe_unused]] auto id1,
+                                 [[maybe_unused]] auto id2) -> exec::task<void>
+  {
     CHECK(get_id() == id_main_thread);
     co_await ex::schedule(sched1);
     CHECK(get_id() == id_main_thread);
   }
 
-  auto test_stick_on_main(
-    ex::scheduler auto sched1,
-    ex::scheduler auto sched2,
-    auto id_main_thread,
-    [[maybe_unused]] auto id1,
-    [[maybe_unused]] auto id2) -> exec::task<void> {
+  auto test_stick_on_main(ex::scheduler auto    sched1,
+                          ex::scheduler auto    sched2,
+                          auto                  id_main_thread,
+                          [[maybe_unused]] auto id1,
+                          [[maybe_unused]] auto id2) -> exec::task<void>
+  {
     CHECK(get_id() == id_main_thread);
     co_await ex::schedule(sched1);
     CHECK(get_id() == id_main_thread);
@@ -212,38 +218,43 @@ namespace {
     CHECK(get_id() == id_main_thread);
   }
 
-  TEST_CASE("Stick on main thread if completes_inline is not used", "[types][sticky][task]") {
+  TEST_CASE("Stick on main thread if completes_inline is not used", "[types][sticky][task]")
+  {
     exec::single_thread_context context1;
     exec::single_thread_context context2;
-    ex::scheduler auto scheduler1 = context1.get_scheduler();
-    ex::scheduler auto scheduler2 = context2.get_scheduler();
-    ex::sync_wait(ex::when_all(
-      ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
-      ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
-    auto id1 = 1;
-    auto id2 = 2;
+    ex::scheduler auto          scheduler1 = context1.get_scheduler();
+    ex::scheduler auto          scheduler2 = context2.get_scheduler();
+    ex::sync_wait(ex::when_all(ex::schedule(scheduler1) | ex::then([] { thread_id = 1; }),
+                               ex::schedule(scheduler2) | ex::then([] { thread_id = 2; })));
+    auto id1            = 1;
+    auto id2            = 2;
     auto id_main_thread = 0;
-    auto t = test_stick_on_main(scheduler1, scheduler2, id_main_thread, id1, id2);
+    auto t              = test_stick_on_main(scheduler1, scheduler2, id_main_thread, id1, id2);
     ex::sync_wait(std::move(t));
   }
 
-  auto check_stop_possible() -> exec::task<void> {
+  auto check_stop_possible() -> exec::task<void>
+  {
     auto stop_token = co_await STDEXEC::get_stop_token();
     CHECK(stop_token.stop_possible());
   }
 
-  TEST_CASE("task - stop token is forwarded", "[types][task]") {
+  TEST_CASE("task - stop token is forwarded", "[types][task]")
+  {
     exec::single_thread_context context{};
-    exec::async_scope scope;
+    exec::async_scope           scope;
     scope.spawn(STDEXEC::starts_on(context.get_scheduler(), check_stop_possible()));
     CHECK(STDEXEC::sync_wait(scope.on_empty()));
   }
 
-  TEST_CASE("task - can stop early", "[types][task]") {
-    int count = 0;
-    auto work = [](int& count) -> exec::task<void> {
+  TEST_CASE("task - can stop early", "[types][task]")
+  {
+    int  count = 0;
+    auto work  = [](int& count) -> exec::task<void>
+    {
       count += 1;
-      co_await [](int& count) -> exec::task<void> {
+      co_await [](int& count) -> exec::task<void>
+      {
         count += 2;
         co_await STDEXEC::just_stopped();
         count += 4;
@@ -256,28 +267,34 @@ namespace {
     CHECK(count == 3);
   }
 
-  TEST_CASE("task - can co_await task wrapped in write_env", "[types][task]") {
-    STDEXEC::sync_wait([]() -> exec::task<void> {
-      co_await STDEXEC::write_env(
-        []() -> exec::task<void> {
-          auto token = co_await STDEXEC::get_stop_token();
-          assert(!token.stop_possible());
-          (void) token;
-        }(),
-        STDEXEC::prop{STDEXEC::get_stop_token, STDEXEC::never_stop_token{}});
-    }());
+  TEST_CASE("task - can co_await task wrapped in write_env", "[types][task]")
+  {
+    STDEXEC::sync_wait(
+      []() -> exec::task<void>
+      {
+        co_await STDEXEC::write_env(
+          []() -> exec::task<void>
+          {
+            auto token = co_await STDEXEC::get_stop_token();
+            assert(!token.stop_possible());
+            (void) token;
+          }(),
+          STDEXEC::prop{STDEXEC::get_stop_token, STDEXEC::never_stop_token{}});
+      }());
   }
 
-  struct test_domain {
+  struct test_domain
+  {
     template <ex::sender_expr_for<ex::then_t> _Sender>
-    static constexpr auto transform_sender(STDEXEC::set_value_t, _Sender&&, auto&&...) noexcept {
+    static constexpr auto transform_sender(STDEXEC::set_value_t, _Sender&&, auto&&...) noexcept
+    {
       return ex::just("goodbye"s);
     }
   };
 
-  struct test_task_context {
-    constexpr test_task_context(auto&&...) noexcept {
-    }
+  struct test_task_context
+  {
+    constexpr test_task_context(auto&&...) noexcept {}
 
     template <class _ThisPromise>
     using promise_context_t = test_task_context;
@@ -285,7 +302,8 @@ namespace {
     template <class, class>
     using awaiter_context_t = test_task_context;
 
-    static constexpr auto query(ex::get_scheduler_t) noexcept {
+    static constexpr auto query(ex::get_scheduler_t) noexcept
+    {
       return basic_inline_scheduler<test_domain>{};
     }
   };
@@ -293,8 +311,10 @@ namespace {
   template <class T>
   using test_task = exec::basic_task<T, test_task_context>;
 
-  TEST_CASE("task - can co_await a sender adaptor closure object", "[types][task]") {
-    auto salutation = []() -> test_task<std::string> {
+  TEST_CASE("task - can co_await a sender adaptor closure object", "[types][task]")
+  {
+    auto salutation = []() -> test_task<std::string>
+    {
       co_return co_await ex::then([] { return "hello"s; });
     }();
     auto [msg] = STDEXEC::sync_wait(std::move(salutation)).value();
@@ -302,11 +322,14 @@ namespace {
   }
 
 #  if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("task - can error early", "[types][task]") {
-    int count = 0;
-    auto work = [](int& count) -> exec::task<void> {
+  TEST_CASE("task - can error early", "[types][task]")
+  {
+    int  count = 0;
+    auto work  = [](int& count) -> exec::task<void>
+    {
       count += 1;
-      co_await [](int& count) -> exec::task<void> {
+      co_await [](int& count) -> exec::task<void>
+      {
         count += 2;
         co_await STDEXEC::just_error(std::runtime_error("on noes"));
         count += 4;
@@ -314,15 +337,18 @@ namespace {
       count += 8;
     }(count);
 
-    try {
+    try
+    {
       STDEXEC::sync_wait(std::move(work));
       CHECK(false);
-    } catch (const std::runtime_error& e) {
+    }
+    catch (std::runtime_error const & e)
+    {
       CHECK(std::string_view(e.what()) == "on noes");
     }
     CHECK(count == 3);
   }
-#  endif // !STDEXEC_NO_STD_EXCEPTIONS()
-} // namespace
+#  endif  // !STDEXEC_NO_STD_EXCEPTIONS()
+}  // namespace
 
 #endif
diff --git a/test/exec/test_timed_thread_scheduler.cpp b/test/exec/test_timed_thread_scheduler.cpp
index ad449bf62..58589debd 100644
--- a/test/exec/test_timed_thread_scheduler.cpp
+++ b/test/exec/test_timed_thread_scheduler.cpp
@@ -26,93 +26,102 @@
 #if STDEXEC_GCC() && STDEXEC_GCC_VERSION < 12'00 && defined(__SANITIZE_THREAD__)
 // nothing
 #else
-namespace {
-  TEST_CASE(
-    "timed_thread_scheduler - unused context",
-    "[types][timed_thread_scheduler][schedulers]") {
+namespace
+{
+  TEST_CASE("timed_thread_scheduler - unused context",
+            "[types][timed_thread_scheduler][schedulers]")
+  {
     static_assert(exec::__timed_scheduler<exec::timed_thread_scheduler>);
     exec::timed_thread_context context;
   }
 
-  TEST_CASE("timed_thread_scheduler - now", "[timed_thread_scheduler][now]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - now", "[timed_thread_scheduler][now]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    auto tp = exec::now(scheduler);
+    auto                         tp        = exec::now(scheduler);
     REQUIRE(tp.time_since_epoch().count() > 0);
   }
 
-  TEST_CASE("timed_thread_scheduler - schedule", "[timed_thread_scheduler][schedule]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - schedule", "[timed_thread_scheduler][schedule]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
     CHECK(STDEXEC::sync_wait(STDEXEC::schedule(scheduler)));
   }
 
-  TEST_CASE("timed_thread_scheduler - schedule_at", "[timed_thread_scheduler][schedule_at]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - schedule_at", "[timed_thread_scheduler][schedule_at]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    auto now = exec::now(scheduler);
-    auto tp = now + std::chrono::milliseconds(10);
+    auto                         now       = exec::now(scheduler);
+    auto                         tp        = now + std::chrono::milliseconds(10);
     CHECK(STDEXEC::sync_wait(exec::schedule_at(scheduler, tp)));
   }
 
-  TEST_CASE("timed_thread_scheduler - schedule_after", "[timed_thread_scheduler][schedule_at]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - schedule_after", "[timed_thread_scheduler][schedule_at]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    auto duration = std::chrono::milliseconds(10);
+    auto                         duration  = std::chrono::milliseconds(10);
     CHECK(STDEXEC::sync_wait(exec::schedule_after(scheduler, duration)));
   }
 
-  TEST_CASE("timed_thread_scheduler - when_any", "[timed_thread_scheduler][when_any]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - when_any", "[timed_thread_scheduler][when_any]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    auto duration1 = std::chrono::milliseconds(10);
-    auto duration2 = std::chrono::seconds(5);
-    auto shorter = exec::when_any(
-      exec::schedule_after(scheduler, duration1) | STDEXEC::then([] { return 1; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 2; }));
-    auto t0 = std::chrono::steady_clock::now();
-    auto [n] = STDEXEC::sync_wait(std::move(shorter)).value();
-    auto t1 = std::chrono::steady_clock::now();
-    auto duration = t1 - t0;
+    auto                         duration1 = std::chrono::milliseconds(10);
+    auto                         duration2 = std::chrono::seconds(5);
+    auto                         shorter = exec::when_any(exec::schedule_after(scheduler, duration1)
+                                    | STDEXEC::then([] { return 1; }),
+                                  exec::schedule_after(scheduler, duration2)
+                                    | STDEXEC::then([] { return 2; }));
+    auto                         t0      = std::chrono::steady_clock::now();
+    auto [n]                             = STDEXEC::sync_wait(std::move(shorter)).value();
+    auto t1                              = std::chrono::steady_clock::now();
+    auto duration                        = t1 - t0;
     CHECK(duration1 <= duration);
     CHECK(n == 1);
   }
 
-  TEST_CASE("timed_thread_scheduler - more when_any", "[timed_thread_scheduler][when_any]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - more when_any", "[timed_thread_scheduler][when_any]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    auto duration1 = std::chrono::milliseconds(10);
-    auto duration2 = std::chrono::seconds(5);
-    auto shorter = exec::when_any(
-      exec::schedule_after(scheduler, duration1) | STDEXEC::then([] { return 1; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 2; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 3; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 4; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 5; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 6; }),
-      exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 7; }));
-    auto t0 = std::chrono::steady_clock::now();
-    auto [n] = STDEXEC::sync_wait(std::move(shorter)).value();
-    auto t1 = std::chrono::steady_clock::now();
+    auto                         duration1 = std::chrono::milliseconds(10);
+    auto                         duration2 = std::chrono::seconds(5);
+    auto                         shorter =
+      exec::when_any(exec::schedule_after(scheduler, duration1) | STDEXEC::then([] { return 1; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 2; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 3; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 4; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 5; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 6; }),
+                     exec::schedule_after(scheduler, duration2) | STDEXEC::then([] { return 7; }));
+    auto t0       = std::chrono::steady_clock::now();
+    auto [n]      = STDEXEC::sync_wait(std::move(shorter)).value();
+    auto t1       = std::chrono::steady_clock::now();
     auto duration = t1 - t0;
     CHECK(duration1 <= duration);
     CHECK(n == 1);
   }
 
-  TEST_CASE(
-    "timed_thread_scheduler - many timers with async scope",
-    "[timed_thread_scheduler][async_scope]") {
-    exec::timed_thread_context context;
+  TEST_CASE("timed_thread_scheduler - many timers with async scope",
+            "[timed_thread_scheduler][async_scope]")
+  {
+    exec::timed_thread_context   context;
     exec::timed_thread_scheduler scheduler = context.get_scheduler();
-    exec::async_scope scope;
-    int counter = 0;
-    int ntimers = 1'000;
-    auto now = exec::now(scheduler);
-    auto deadline = now + std::chrono::milliseconds(100);
-    auto t0 = std::chrono::steady_clock::now();
-    for (int i = 0; i < ntimers; ++i) {
-      scope
-        .spawn(exec::schedule_at(scheduler, deadline) | STDEXEC::then([&counter] { ++counter; }));
+    exec::async_scope            scope;
+    int                          counter  = 0;
+    int                          ntimers  = 1'000;
+    auto                         now      = exec::now(scheduler);
+    auto                         deadline = now + std::chrono::milliseconds(100);
+    auto                         t0       = std::chrono::steady_clock::now();
+    for (int i = 0; i < ntimers; ++i)
+    {
+      scope.spawn(exec::schedule_at(scheduler, deadline)
+                  | STDEXEC::then([&counter] { ++counter; }));
     }
     CHECK(STDEXEC::sync_wait(scope.on_empty()));
     auto t1 = std::chrono::steady_clock::now();
@@ -120,5 +129,5 @@ namespace {
     auto duration = t1 - t0;
     CHECK(duration > std::chrono::milliseconds(100));
   }
-} // namespace
+}  // namespace
 #endif
\ No newline at end of file
diff --git a/test/exec/test_trampoline_scheduler.cpp b/test/exec/test_trampoline_scheduler.cpp
index 9620146ab..7ade514ab 100644
--- a/test/exec/test_trampoline_scheduler.cpp
+++ b/test/exec/test_trampoline_scheduler.cpp
@@ -24,31 +24,40 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  struct try_again { };
+  struct try_again
+  {};
 
-  struct fails_alot {
+  struct fails_alot
+  {
     using sender_concept = ex::sender_t;
     using completion_signatures =
       ex::completion_signatures<ex::set_value_t(), ex::set_error_t(try_again)>;
 
     template <class Receiver>
-    struct operation {
+    struct operation
+    {
       Receiver rcvr_;
-      int counter_;
+      int      counter_;
 
-      void start() & noexcept {
-        if (counter_ == 0) {
+      void start() & noexcept
+      {
+        if (counter_ == 0)
+        {
           ex::set_value(static_cast<Receiver&&>(rcvr_));
-        } else {
+        }
+        else
+        {
           ex::set_error(static_cast<Receiver&&>(rcvr_), try_again{});
         }
       }
     };
 
     template <ex::receiver_of<completion_signatures> Receiver>
-    auto connect(Receiver rcvr) const -> operation<Receiver> {
+    auto connect(Receiver rcvr) const -> operation<Receiver>
+    {
       return {static_cast<Receiver&&>(rcvr), --*counter_};
     }
 
@@ -65,15 +74,14 @@ namespace {
   // }
   // #endif
 
-  TEST_CASE(
-    "running deeply recursing algo on trampoline_scheduler doesn't blow the stack",
-    "[schedulers][trampoline_scheduler]") {
-
+  TEST_CASE("running deeply recursing algo on trampoline_scheduler doesn't blow the stack",
+            "[schedulers][trampoline_scheduler]")
+  {
     exec::trampoline_scheduler sched;
-    ex::run_loop loop;
+    ex::run_loop               loop;
 
     auto recurse_deeply = retry(ex::on(sched, fails_alot{}));
     ex::sync_wait(std::move(recurse_deeply));
   }
 
-} // namespace
+}  // namespace
diff --git a/test/exec/test_type_async_scope.cpp b/test/exec/test_type_async_scope.cpp
index 0dd764914..8d55c7420 100644
--- a/test/exec/test_type_async_scope.cpp
+++ b/test/exec/test_type_async_scope.cpp
@@ -28,45 +28,50 @@ namespace ex = STDEXEC;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
-namespace {
-  void expect_empty(exec::async_scope& scope) {
-    ex::run_loop loop;
+namespace
+{
+  void expect_empty(exec::async_scope& scope)
+  {
+    ex::run_loop       loop;
     ex::scheduler auto sch = loop.get_scheduler();
     CHECK_FALSE(ex::execute_may_block_caller(sch));
-    auto op = ex::connect(
-      ex::then(
-        scope.on_empty(),
-        [&]() {
-          loop.finish();
+    auto op = ex::connect(ex::then(scope.on_empty(),
+                                   [&]()
+                                   {
+                                     loop.finish();
     }),
-      expect_void_receiver{ex::prop{ex::get_scheduler, sch}});
+                          expect_void_receiver{ex::prop{ex::get_scheduler, sch}});
     ex::start(op);
     loop.run();
   }
 
-  TEST_CASE("async_scope will complete", "[types][type_async_scope]") {
+  TEST_CASE("async_scope will complete", "[types][type_async_scope]")
+  {
     exec::static_thread_pool ctx{1};
 
     ex::scheduler auto sch = ctx.get_scheduler();
 
-    SECTION("after construction") {
+    SECTION("after construction")
+    {
       exec::async_scope scope;
       expect_empty(scope);
     }
 
-    SECTION("after spawn") {
+    SECTION("after spawn")
+    {
       exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
+      ex::sender auto   begin = ex::schedule(sch);
       scope.spawn(begin);
       ex::sync_wait(scope.on_empty());
       expect_empty(scope);
     }
 
-    SECTION("after nest result discarded") {
+    SECTION("after nest result discarded")
+    {
       exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
+      ex::sender auto   begin = ex::schedule(sch);
       {
         ex::sender auto nst = scope.nest(begin);
         (void) nst;
@@ -75,21 +80,23 @@ namespace {
       expect_empty(scope);
     }
 
-    SECTION("after nest result started") {
+    SECTION("after nest result started")
+    {
       exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
-      ex::sender auto nst = scope.nest(begin);
-      auto op = ex::connect(std::move(nst), expect_void_receiver{});
+      ex::sender auto   begin = ex::schedule(sch);
+      ex::sender auto   nst   = scope.nest(begin);
+      auto              op    = ex::connect(std::move(nst), expect_void_receiver{});
       ex::start(op);
       ex::sync_wait(scope.on_empty());
       expect_empty(scope);
     }
 
-    SECTION("after spawn_future result discarded") {
+    SECTION("after spawn_future result discarded")
+    {
       exec::static_thread_pool ctx{1};
-      exec::async_scope scope;
-      std::atomic_bool produced{false};
-      ex::sender auto begin = ex::schedule(sch);
+      exec::async_scope        scope;
+      std::atomic_bool         produced{false};
+      ex::sender auto          begin = ex::schedule(sch);
       {
         ex::sender auto ftr = scope.spawn_future(begin | ex::then([&]() { produced = true; }));
         (void) ftr;
@@ -98,11 +105,12 @@ namespace {
       expect_empty(scope);
     }
 
-    SECTION("after spawn_future result started") {
+    SECTION("after spawn_future result started")
+    {
       exec::static_thread_pool ctx{1};
-      exec::async_scope scope;
-      std::atomic_bool produced{false};
-      ex::sender auto begin = ex::schedule(sch);
+      exec::async_scope        scope;
+      std::atomic_bool         produced{false};
+      ex::sender auto          begin = ex::schedule(sch);
       ex::sender auto ftr = scope.spawn_future(begin | ex::then([&]() { produced = true; }));
       ex::sync_wait(scope.on_empty() | ex::then([&]() { STDEXEC_ASSERT(produced.load()); }));
       auto op = ex::connect(std::move(ftr), expect_void_receiver{});
@@ -111,14 +119,15 @@ namespace {
       expect_empty(scope);
     }
 
-    SECTION("request_stop nested spawn_future") {
+    SECTION("request_stop nested spawn_future")
+    {
       exec::static_thread_pool ctx{1};
-      exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
-      ex::sender auto ftr = scope.spawn_future(scope.spawn_future(begin));
+      exec::async_scope        scope;
+      ex::sender auto          begin = ex::schedule(sch);
+      ex::sender auto          ftr   = scope.spawn_future(scope.spawn_future(begin));
       scope.request_stop();
       ex::sync_wait(ex::when_all(scope.on_empty(), std::move(ftr)));
       // Verify the program finishes without crashing
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_unless_stop_requested.cpp b/test/exec/test_unless_stop_requested.cpp
index 806b7ba54..4bd990785 100644
--- a/test/exec/test_unless_stop_requested.cpp
+++ b/test/exec/test_unless_stop_requested.cpp
@@ -26,11 +26,12 @@
 #include "../test_common/receivers.hpp"
 #include "../test_common/type_helpers.hpp"
 
-namespace {
+namespace
+{
 
-  TEST_CASE(
-    "When stop has not been requested the child operation runs normally",
-    "[unless_stop_requested]") {
+  TEST_CASE("When stop has not been requested the child operation runs normally",
+            "[unless_stop_requested]")
+  {
     ::STDEXEC::inplace_stop_source source;
     auto env = ::STDEXEC::prop(::STDEXEC::get_stop_token, source.get_token());
     static_assert(!::exec::__unless_stop_requested::__unstoppable_env<decltype(env)>);
@@ -39,26 +40,24 @@ namespace {
       static_assert(
         set_equivalent<
           ::STDEXEC::completion_signatures_of_t<decltype(sender), decltype(env)>,
-          ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(), ::STDEXEC::set_stopped_t()>
-        >);
+          ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(), ::STDEXEC::set_stopped_t()>>);
       auto op = ::STDEXEC::connect(sender, expect_void_receiver(env));
       ::STDEXEC::start(op);
     }
     {
       auto sender = ::STDEXEC::just(5) | ::exec::unless_stop_requested();
       static_assert(
-        set_equivalent<
-          ::STDEXEC::completion_signatures_of_t<decltype(sender), decltype(env)>,
-          ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(int), ::STDEXEC::set_stopped_t()>
-        >);
+        set_equivalent<::STDEXEC::completion_signatures_of_t<decltype(sender), decltype(env)>,
+                       ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(int),
+                                                        ::STDEXEC::set_stopped_t()>>);
       auto op = ::STDEXEC::connect(sender, expect_value_receiver(env_tag{}, env, 5));
       ::STDEXEC::start(op);
     }
   }
 
-  TEST_CASE(
-    "When stop has been requested the child operation is not started",
-    "[unless_stop_requested]") {
+  TEST_CASE("When stop has been requested the child operation is not started",
+            "[unless_stop_requested]")
+  {
     ::STDEXEC::inplace_stop_source source;
     source.request_stop();
     auto env = ::STDEXEC::prop(::STDEXEC::get_stop_token, source.get_token());
@@ -66,27 +65,24 @@ namespace {
     auto sender = ::STDEXEC::just()
                 | ::STDEXEC::then([&]() { FAIL_CHECK("Operation should not have been started"); })
                 | ::exec::unless_stop_requested();
-    static_assert(set_equivalent<
-                  ::STDEXEC::completion_signatures_of_t<decltype(sender), decltype(env)>,
-                  ::STDEXEC::completion_signatures<
-                    ::STDEXEC::set_value_t(),
-                    ::STDEXEC::set_error_t(std::exception_ptr),
-                    ::STDEXEC::set_stopped_t()
-                  >
-    >);
+    static_assert(
+      set_equivalent<::STDEXEC::completion_signatures_of_t<decltype(sender), decltype(env)>,
+                     ::STDEXEC::completion_signatures<::STDEXEC::set_value_t(),
+                                                      ::STDEXEC::set_error_t(std::exception_ptr),
+                                                      ::STDEXEC::set_stopped_t()>>);
     auto op = ::STDEXEC::connect(sender, expect_stopped_receiver(env));
     ::STDEXEC::start(op);
   }
 
-  TEST_CASE("No op when the associated stop token is unstoppable", "[unless_stop_requested]") {
+  TEST_CASE("No op when the associated stop token is unstoppable", "[unless_stop_requested]")
+  {
     static_assert(::exec::__unless_stop_requested::__unstoppable_env<::STDEXEC::env<>>);
     auto sender = ::STDEXEC::just() | ::exec::unless_stop_requested;
-    static_assert(set_equivalent<
-                  ::STDEXEC::completion_signatures_of_t<decltype(sender), ::STDEXEC::env<>>,
-                  ::STDEXEC::completion_signatures<::STDEXEC::set_value_t()>
-    >);
+    static_assert(
+      set_equivalent<::STDEXEC::completion_signatures_of_t<decltype(sender), ::STDEXEC::env<>>,
+                     ::STDEXEC::completion_signatures<::STDEXEC::set_value_t()>>);
     auto op = ::STDEXEC::connect(sender, expect_void_receiver{});
     ::STDEXEC::start(op);
   }
 
-} // unnamed namespace
+}  // unnamed namespace
diff --git a/test/exec/test_variant_sender.cpp b/test/exec/test_variant_sender.cpp
index a48e10f45..4be5ab36b 100644
--- a/test/exec/test_variant_sender.cpp
+++ b/test/exec/test_variant_sender.cpp
@@ -22,52 +22,56 @@
 using namespace STDEXEC;
 using namespace exec;
 
-namespace {
+namespace
+{
 
   template <class... Ts>
-  struct overloaded : Ts... {
+  struct overloaded : Ts...
+  {
     using Ts::operator()...;
   };
   template <class... Ts>
   overloaded(Ts...) -> overloaded<Ts...>;
 
-  using just_int_t = decltype(just(0));
-  using just_void_t = decltype(just());
-  using just_then_void_t = decltype(then(just(), [] { }));
+  using just_int_t       = decltype(just(0));
+  using just_void_t      = decltype(just());
+  using just_then_void_t = decltype(then(just(), [] {}));
 
-  TEST_CASE("variant_sender - default constructible", "[types][variant_sender]") {
+  TEST_CASE("variant_sender - default constructible", "[types][variant_sender]")
+  {
     variant_sender<just_void_t, just_int_t> variant{just()};
     STATIC_REQUIRE(sender_in<decltype(variant)>);
     CHECK(variant.index() == 0);
   }
 
-  TEST_CASE("variant_sender - sender_of concept", "[types][variant_sender]") {
+  TEST_CASE("variant_sender - sender_of concept", "[types][variant_sender]")
+  {
     variant_sender<just_void_t, just_then_void_t> variant{just()};
     STATIC_REQUIRE(sender_of<decltype(variant), set_value_t()>);
   }
 
-  TEST_CASE("variant_sender - using an overloaded then adaptor", "[types][variant_sender]") {
+  TEST_CASE("variant_sender - using an overloaded then adaptor", "[types][variant_sender]")
+  {
     variant_sender<just_void_t, just_int_t> variant = just();
-    int index = -1;
+    int                                     index   = -1;
     STATIC_REQUIRE(sender<variant_sender<just_void_t, just_int_t>>);
     sync_wait(variant | then([&index](auto... xs) { index = sizeof...(xs); }));
     CHECK(index == 0);
 
     variant.emplace<1>(just(42));
-    auto [value] = sync_wait(
-                     variant
-                     | then(
-                       overloaded{
-                         [&index] {
-                           index = 0;
-                           return 0;
-                         },
-                         [&index](int xs) {
-                           index = 1;
-                           return xs;
-                         }}))
+    auto [value] = sync_wait(variant
+                             | then(overloaded{[&index]
+                                               {
+                                                 index = 0;
+                                                 return 0;
+                                               },
+                                               [&index](int xs)
+                                               {
+                                                 index = 1;
+                                                 return xs;
+                                               }}))
                      .value();
     CHECK(index == 1);
     CHECK(value == 42);
   }
-} // namespace
+}  // namespace
diff --git a/test/exec/test_when_any.cpp b/test/exec/test_when_any.cpp
index a54257807..fd515d7fe 100644
--- a/test/exec/test_when_any.cpp
+++ b/test/exec/test_when_any.cpp
@@ -28,76 +28,83 @@ namespace ex = STDEXEC;
 
 using namespace STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("when_ny returns a sender", "[adaptors][when_any]") {
+  TEST_CASE("when_ny returns a sender", "[adaptors][when_any]")
+  {
     auto snd = exec::when_any(ex::just(3), ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("when_any with environment returns a sender", "[adaptors][when_any]") {
+  TEST_CASE("when_any with environment returns a sender", "[adaptors][when_any]")
+  {
     auto snd = exec::when_any(ex::just(3), ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("when_any simple example", "[adaptors][when_any]") {
-    auto snd = exec::when_any(ex::just(3.0));
-    auto snd1 = std::move(snd) | ex::then([](double y) { return y + 0.1415; });
-    const double expected = 3.0 + 0.1415;
-    auto op = ex::connect(std::move(snd1), expect_value_receiver{expected});
+  TEST_CASE("when_any simple example", "[adaptors][when_any]")
+  {
+    auto         snd      = exec::when_any(ex::just(3.0));
+    auto         snd1     = std::move(snd) | ex::then([](double y) { return y + 0.1415; });
+    double const expected = 3.0 + 0.1415;
+    auto         op       = ex::connect(std::move(snd1), expect_value_receiver{expected});
     ex::start(op);
   }
 
-  TEST_CASE("when_any completes with only one sender", "[adaptors][when_any]") {
-    ex::sender auto snd = exec::when_any(
-      completes_if{false} | ex::then([] { return 1; }),
-      completes_if{true} | ex::then([] { return 42; }));
+  TEST_CASE("when_any completes with only one sender", "[adaptors][when_any]")
+  {
+    ex::sender auto snd = exec::when_any(completes_if{false} | ex::then([] { return 1; }),
+                                         completes_if{true} | ex::then([] { return 42; }));
     wait_for_value(std::move(snd), 42);
 
-    ex::sender auto snd2 = exec::when_any(
-      completes_if{true} | ex::then([] { return 1; }),
-      completes_if{false} | ex::then([] { return 42; }));
+    ex::sender auto snd2 = exec::when_any(completes_if{true} | ex::then([] { return 1; }),
+                                          completes_if{false} | ex::then([] { return 42; }));
     wait_for_value(std::move(snd2), 1);
   }
 
-  TEST_CASE("when_any with move-only types", "[adaptors][when_any]") {
-    ex::sender auto snd = exec::when_any(
-      completes_if{false} | ex::then([] { return movable(1); }), ex::just(movable(42)));
+  TEST_CASE("when_any with move-only types", "[adaptors][when_any]")
+  {
+    ex::sender auto snd = exec::when_any(completes_if{false} | ex::then([] { return movable(1); }),
+                                         ex::just(movable(42)));
     wait_for_value(std::move(snd), movable(42));
   }
 
-  TEST_CASE("when_any forwards stop signal", "[adaptors][when_any]") {
+  TEST_CASE("when_any forwards stop signal", "[adaptors][when_any]")
+  {
     stopped_scheduler stop;
-    int result = 42;
-    ex::sender auto snd = exec::when_any(completes_if{false}, ex::schedule(stop))
+    int               result = 42;
+    ex::sender auto   snd    = exec::when_any(completes_if{false}, ex::schedule(stop))
                         | ex::then([&result] { result += 1; });
     ex::sync_wait(std::move(snd));
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("nested when_any is stoppable", "[adaptors][when_any]") {
-    int result = 41;
-    ex::sender auto snd = exec::when_any(
-                            exec::when_any(completes_if{false}, completes_if{false}),
-                            completes_if{false},
-                            ex::just(),
-                            completes_if{false})
+  TEST_CASE("nested when_any is stoppable", "[adaptors][when_any]")
+  {
+    int             result = 41;
+    ex::sender auto snd = exec::when_any(exec::when_any(completes_if{false}, completes_if{false}),
+                                         completes_if{false},
+                                         ex::just(),
+                                         completes_if{false})
                         | ex::then([&result] { result += 1; });
     ex::sync_wait(std::move(snd));
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("stop is forwarded", "[adaptors][when_any]") {
-    int result = 41;
-    ex::sender auto snd = exec::when_any(ex::just_stopped(), completes_if{false})
+  TEST_CASE("stop is forwarded", "[adaptors][when_any]")
+  {
+    int             result = 41;
+    ex::sender auto snd    = exec::when_any(ex::just_stopped(), completes_if{false})
                         | ex::upon_stopped([&result] { result += 1; });
     ex::sync_wait(std::move(snd));
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("when_any is thread-safe", "[adaptors][when_any]") {
+  TEST_CASE("when_any is thread-safe", "[adaptors][when_any]")
+  {
     exec::single_thread_context ctx1;
     exec::single_thread_context ctx2;
     exec::single_thread_context ctx3;
@@ -108,122 +115,109 @@ namespace {
 
     int result = 41;
 
-    ex::sender auto snd = exec::when_any(
-      sch1 | ex::let_value([] { return exec::when_any(completes_if{false}); }),
-      sch2 | ex::let_value([] { return completes_if{false}; }),
-      sch3 | ex::then([&result] { result += 1; }),
-      completes_if{false});
+    ex::sender auto snd =
+      exec::when_any(sch1 | ex::let_value([] { return exec::when_any(completes_if{false}); }),
+                     sch2 | ex::let_value([] { return completes_if{false}; }),
+                     sch3 | ex::then([&result] { result += 1; }),
+                     completes_if{false});
 
     ex::sync_wait(std::move(snd));
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("when_any completion signatures", "[adaptors][when_any]") {
-    struct move_throws {
+  TEST_CASE("when_any completion signatures", "[adaptors][when_any]")
+  {
+    struct move_throws
+    {
       move_throws() = default;
 
-      move_throws(move_throws&&) noexcept(false) {
-      }
+      move_throws(move_throws&&) noexcept(false) {}
 
-      auto operator=(move_throws&&) noexcept(false) -> move_throws& {
+      auto operator=(move_throws&&) noexcept(false) -> move_throws&
+      {
         return *this;
       }
     };
 
     auto just = exec::when_any(ex::just());
     static_assert(sender<decltype(just)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just)>,
-                  completion_signatures<set_value_t(), set_stopped_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just)>,
+                                 completion_signatures<set_value_t(), set_stopped_t()>>);
 
     auto just_string = exec::when_any(ex::just(std::string("foo")));
     static_assert(sender<decltype(just_string)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_string)>,
-                  completion_signatures<set_value_t(std::string), set_stopped_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_string)>,
+                                 completion_signatures<set_value_t(std::string), set_stopped_t()>>);
 
     auto just_stopped = exec::when_any(ex::just_stopped());
     static_assert(sender<decltype(just_stopped)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_stopped)>,
-                  completion_signatures<set_stopped_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_stopped)>,
+                                 completion_signatures<set_stopped_t()>>);
 
     auto just_then = exec::when_any(ex::just() | ex::then([] { return 42; }));
     static_assert(sender<decltype(just_then)>);
     static_assert(
       set_equivalent<
         completion_signatures_of_t<decltype(just_then)>,
-        completion_signatures<set_value_t(int), set_stopped_t(), set_error_t(std::exception_ptr)>
-      >);
+        completion_signatures<set_value_t(int), set_stopped_t(), set_error_t(std::exception_ptr)>>);
 
     auto just_then_noexcept = exec::when_any(ex::just() | ex::then([]() noexcept { return 42; }));
     static_assert(sender<decltype(just_then_noexcept)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_then_noexcept)>,
-                  completion_signatures<set_value_t(int), set_stopped_t()>
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_then_noexcept)>,
+                                 completion_signatures<set_value_t(int), set_stopped_t()>>);
 
     auto just_move_throws = exec::when_any(ex::just(move_throws{}));
     static_assert(sender<decltype(just_move_throws)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(just_move_throws)>,
-                  completion_signatures<
-                    set_value_t(move_throws),
-                    set_stopped_t(),
-                    set_error_t(std::exception_ptr)
-                  >
-    >);
-
-    auto mulitple_senders = exec::when_any(
-      ex::just(std::numbers::pi),
-      ex::just(std::string()),
-      ex::just(std::string()),
-      ex::just() | ex::then([] { return 42; }),
-      ex::just() | ex::then([] { return 42; }));
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(just_move_throws)>,
+                                 completion_signatures<set_value_t(move_throws),
+                                                       set_stopped_t(),
+                                                       set_error_t(std::exception_ptr)>>);
+
+    auto mulitple_senders = exec::when_any(ex::just(std::numbers::pi),
+                                           ex::just(std::string()),
+                                           ex::just(std::string()),
+                                           ex::just() | ex::then([] { return 42; }),
+                                           ex::just() | ex::then([] { return 42; }));
     static_assert(sender<decltype(mulitple_senders)>);
-    static_assert(set_equivalent<
-                  completion_signatures_of_t<decltype(mulitple_senders)>,
-                  completion_signatures<
-                    set_value_t(double),
-                    set_value_t(std::string),
-                    set_value_t(int),
-                    set_stopped_t(),
-                    set_error_t(std::exception_ptr)
-                  >
-    >);
+    static_assert(set_equivalent<completion_signatures_of_t<decltype(mulitple_senders)>,
+                                 completion_signatures<set_value_t(double),
+                                                       set_value_t(std::string),
+                                                       set_value_t(int),
+                                                       set_stopped_t(),
+                                                       set_error_t(std::exception_ptr)>>);
     // wait_for_value(std::move(snd), movable(42));
   }
 
   template <class Receiver>
-  struct dup_op {
+  struct dup_op
+  {
     Receiver rec;
 
-    void start() & noexcept {
-      STDEXEC::set_error(
-        static_cast<Receiver&&>(rec), std::make_exception_ptr(std::runtime_error("dup")));
+    void start() & noexcept
+    {
+      STDEXEC::set_error(static_cast<Receiver&&>(rec),
+                         std::make_exception_ptr(std::runtime_error("dup")));
     }
   };
 
-  struct dup_sender {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = STDEXEC::completion_signatures<
-      set_value_t(),
-      set_error_t(std::exception_ptr),
-      set_error_t(std::exception_ptr&&)
-    >;
+  struct dup_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = STDEXEC::completion_signatures<set_value_t(),
+                                                                 set_error_t(std::exception_ptr),
+                                                                 set_error_t(std::exception_ptr&&)>;
 
     template <class Receiver>
-    auto connect(Receiver rec) const noexcept -> dup_op<Receiver> {
+    auto connect(Receiver rec) const noexcept -> dup_op<Receiver>
+    {
       return {static_cast<Receiver&&>(rec)};
     }
   };
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("when_any - with duplicate completions", "[adaptors][when_any]") {
+  TEST_CASE("when_any - with duplicate completions", "[adaptors][when_any]")
+  {
     REQUIRE_THROWS(STDEXEC::sync_wait(exec::when_any(dup_sender{})));
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
-} // namespace
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
+}  // namespace
diff --git a/test/exec/test_windows_thread_pool_context.cpp b/test/exec/test_windows_thread_pool_context.cpp
index d54017b92..06db76236 100644
--- a/test/exec/test_windows_thread_pool_context.cpp
+++ b/test/exec/test_windows_thread_pool_context.cpp
@@ -24,39 +24,42 @@
 
 using namespace std::chrono_literals;
 
-TEST_CASE("windows_thread_pool: construct_destruct", "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: construct_destruct", "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp;
 }
 
-TEST_CASE("windows_thread_pool: custom_thread_pool", "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: custom_thread_pool", "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp{2, 4};
-  auto s = tp.get_scheduler();
+  auto                      s = tp.get_scheduler();
 
   std::atomic<int> count = 0;
 
   auto incrementCountOnTp = STDEXEC::then(STDEXEC::schedule(s), [&] { ++count; });
 
-  STDEXEC::sync_wait(
-    STDEXEC::when_all(
-      incrementCountOnTp, incrementCountOnTp, incrementCountOnTp, incrementCountOnTp));
+  STDEXEC::sync_wait(STDEXEC::when_all(incrementCountOnTp,
+                                       incrementCountOnTp,
+                                       incrementCountOnTp,
+                                       incrementCountOnTp));
 
   REQUIRE(count.load() == 4);
 }
 
-TEST_CASE("windows_thread_pool: schedule", "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: schedule", "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp;
   STDEXEC::sync_wait(STDEXEC::schedule(tp.get_scheduler()));
 }
 
-TEST_CASE(
-  "windows_thread_pool: schedule_completes_on_a_different_thread",
-  "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: schedule_completes_on_a_different_thread",
+          "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp;
-  const auto mainThreadId = std::this_thread::get_id();
-  auto [workThreadId] = STDEXEC::sync_wait(
-                          STDEXEC::then(
-                            STDEXEC::schedule(tp.get_scheduler()),
-                            [&]() noexcept { return std::this_thread::get_id(); }))
+  auto const                mainThreadId = std::this_thread::get_id();
+  auto [workThreadId] = STDEXEC::sync_wait(STDEXEC::then(STDEXEC::schedule(tp.get_scheduler()),
+                                                         [&]() noexcept
+                                                         { return std::this_thread::get_id(); }))
                           .value();
   REQUIRE_FALSE(workThreadId == mainThreadId);
 }
@@ -84,9 +87,10 @@ TEST_CASE(
 //       [n = 0]() mutable noexcept { return n++ == 1000; }));
 // }
 
-TEST_CASE("windows_thread_pool: schedule_after", "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: schedule_after", "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp;
-  auto s = tp.get_scheduler();
+  auto                      s = tp.get_scheduler();
 
   auto startTime = exec::now(s);
 
@@ -119,9 +123,10 @@ TEST_CASE("windows_thread_pool: schedule_after", "[types][windows_thread_pool][s
 //   REQUIRE(duration < 1s);
 // }
 
-TEST_CASE("windows_thread_pool: schedule_at", "[types][windows_thread_pool][schedulers]") {
+TEST_CASE("windows_thread_pool: schedule_at", "[types][windows_thread_pool][schedulers]")
+{
   exec::windows_thread_pool tp;
-  auto s = tp.get_scheduler();
+  auto                      s = tp.get_scheduler();
 
   auto startTime = exec::now(s);
 
diff --git a/test/nvexec/bulk.cpp b/test/nvexec/bulk.cpp
index 984cd6b41..b617c63e6 100644
--- a/test/nvexec/bulk.cpp
+++ b/test/nvexec/bulk.cpp
@@ -10,181 +10,227 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec bulk returns a sender", "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk returns a sender", "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto snd = ex::bulk(ex::schedule(stream_ctx.get_scheduler()), ex::par, 42, [](int) { });
+    auto snd = ex::bulk(ex::schedule(stream_ctx.get_scheduler()), ex::par, 42, [](int) {});
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec bulk executes on GPU", "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk executes on GPU", "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<4> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::bulk(ex::par, 4, [=](int idx) {
-                 if (is_on_gpu()) {
-                   flags.set(idx);
-                 }
-               });
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::bulk(ex::par,
+                        4,
+                        [=](int idx)
+                        {
+                          if (is_on_gpu())
+                          {
+                            flags.set(idx);
+                          }
+                        });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec bulk forwards values on GPU", "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk forwards values on GPU", "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<1024> flags_storage{};
-    auto flags = flags_storage.get();
+    auto                  flags = flags_storage.get();
 
     auto snd = ex::just(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::bulk(ex::par, 1024, [=](int idx, int val) {
-                 if (is_on_gpu()) {
-                   if (val == 42) {
-                     flags.set(idx);
-                   }
-                 }
-               });
+             | ex::bulk(ex::par,
+                        1024,
+                        [=](int idx, int val)
+                        {
+                          if (is_on_gpu())
+                          {
+                            if (val == 42)
+                            {
+                              flags.set(idx);
+                            }
+                          }
+                        });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec bulk forwards multiple values on GPU", "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk forwards multiple values on GPU", "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
     auto snd = ex::just(42, 4.2) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::bulk(ex::par, 2, [=](int idx, int i, double d) {
-                 if (is_on_gpu()) {
-                   if (i == 42 && d == 4.2) {
-                     flags.set(idx);
-                   }
-                 }
-               });
-    const auto [i, d] = STDEXEC::sync_wait(std::move(snd)).value();
+             | ex::bulk(ex::par,
+                        2,
+                        [=](int idx, int i, double d)
+                        {
+                          if (is_on_gpu())
+                          {
+                            if (i == 42 && d == 4.2)
+                            {
+                              flags.set(idx);
+                            }
+                          }
+                        });
+    auto const [i, d] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(flags_storage.all_set_once());
     REQUIRE(i == 42);
     REQUIRE(d == 4.2);
   }
 
-  TEST_CASE(
-    "bulk forwards values that can be taken by reference on GPU",
-    "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("bulk forwards values that can be taken by reference on GPU",
+            "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<1024> flags_storage{};
     using flags_t = flags_storage_t<1024>::flags_t;
-    auto flags = flags_storage.get();
+    auto flags    = flags_storage.get();
 
     auto snd = ex::just(flags) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::bulk(ex::par, 1024, [](int idx, const flags_t& flags) {
-                 if (is_on_gpu()) {
-                   flags.set(idx);
-                 }
-               });
+             | ex::bulk(ex::par,
+                        1024,
+                        [](int idx, flags_t const & flags)
+                        {
+                          if (is_on_gpu())
+                          {
+                            flags.set(idx);
+                          }
+                        });
     [[maybe_unused]] auto [flags_actual] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec bulk can preceed a sender without values", "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk can preceed a sender without values", "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<3> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
     auto snd = ex::schedule(stream_ctx.get_scheduler())
-             | ex::bulk(
-                 ex::par,
-                 2,
-                 [flags](int idx) {
-                   if (is_on_gpu()) {
-                     flags.set(idx);
+             | ex::bulk(ex::par,
+                        2,
+                        [flags](int idx)
+                        {
+                          if (is_on_gpu())
+                          {
+                            flags.set(idx);
+                          }
+                        })
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(2);
                    }
-                 })
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(2);
-                 }
-               });
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec bulk can succeed a sender", "[cuda][stream][adaptors][bulk]") {
-    SECTION("without values") {
+  TEST_CASE("nvexec bulk can succeed a sender", "[cuda][stream][adaptors][bulk]")
+  {
+    SECTION("without values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t<3> flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t<3>     flags_storage{};
+      auto                   flags = flags_storage.get();
 
-      auto snd = ex::schedule(stream_ctx.get_scheduler()) | a_sender([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(2);
-                   }
-                 })
-               | ex::bulk(ex::par, 2, [flags](int idx) {
-                   if (is_on_gpu()) {
-                     flags.set(idx);
-                   }
-                 });
+      auto snd = ex::schedule(stream_ctx.get_scheduler())
+               | a_sender(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(2);
+                     }
+                   })
+               | ex::bulk(ex::par,
+                          2,
+                          [flags](int idx)
+                          {
+                            if (is_on_gpu())
+                            {
+                              flags.set(idx);
+                            }
+                          });
       STDEXEC::sync_wait(std::move(snd));
 
       REQUIRE(flags_storage.all_set_once());
     }
 
-    SECTION("with values") {
+    SECTION("with values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t<2> flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t<2>     flags_storage{};
+      auto                   flags = flags_storage.get();
 
       auto snd = ex::schedule(stream_ctx.get_scheduler())
                | a_sender([]() -> bool { return is_on_gpu(); })
-               | ex::bulk(ex::par, 2, [flags](int idx, bool a_sender_was_on_gpu) {
-                   if (a_sender_was_on_gpu && is_on_gpu()) {
-                     flags.set(idx);
-                   }
-                 });
+               | ex::bulk(ex::par,
+                          2,
+                          [flags](int idx, bool a_sender_was_on_gpu)
+                          {
+                            if (a_sender_was_on_gpu && is_on_gpu())
+                            {
+                              flags.set(idx);
+                            }
+                          });
       STDEXEC::sync_wait(std::move(snd)).value();
 
       REQUIRE(flags_storage.all_set_once());
     }
   }
 
-  TEST_CASE(
-    "nvexec bulk can succeed a sender that sends ref into opstate",
-    "[cuda][stream][adaptors][bulk]") {
+  TEST_CASE("nvexec bulk can succeed a sender that sends ref into opstate",
+            "[cuda][stream][adaptors][bulk]")
+  {
     nvexec::stream_context ctx;
 
-    double* inout = nullptr;
-    const int nelems = 10;
+    double*   inout  = nullptr;
+    int const nelems = 10;
     cudaMallocManaged(&inout, nelems * sizeof(double));
 
     auto task = STDEXEC::just(cuda::std::span<double>{inout, nelems})
               | STDEXEC::continues_on(ctx.get_scheduler())
-              | STDEXEC::bulk(
-                  ex::par,
-                  nelems,
-                  [](std::size_t i, cuda::std::span<double> out) { out[i] = (double) i; })
+              | STDEXEC::bulk(ex::par,
+                              nelems,
+                              [](std::size_t i, cuda::std::span<double> out)
+                              { out[i] = (double) i; })
               | STDEXEC::let_value([](cuda::std::span<double> out) { return STDEXEC::just(out); })
-              | STDEXEC::bulk(ex::par, nelems, [](std::size_t i, cuda::std::span<double> out) {
-                  out[i] = 2.0 * out[i];
-                });
+              | STDEXEC::bulk(ex::par,
+                              nelems,
+                              [](std::size_t i, cuda::std::span<double> out)
+                              { out[i] = 2.0 * out[i]; });
 
     STDEXEC::sync_wait(std::move(task)).value();
 
-    for (int i = 0; i < nelems; ++i) {
+    for (int i = 0; i < nelems; ++i)
+    {
       REQUIRE(i * 2 == (int) inout[i]);
     }
 
     cudaFree(inout);
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/ensure_started.cpp b/test/nvexec/ensure_started.cpp
index 85c1542f5..7b8dd8d82 100644
--- a/test/nvexec/ensure_started.cpp
+++ b/test/nvexec/ensure_started.cpp
@@ -11,19 +11,25 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec ensure_started is eager", "[cuda][stream][adaptors][ensure_started]") {
+  TEST_CASE("nvexec ensure_started is eager", "[cuda][stream][adaptors][ensure_started]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] {
-                                      if (is_on_gpu()) {
-                                        flags.set();
-                                      }
-                                    }));
+    auto            flags = flags_storage.get();
+
+    auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler())
+                                    | ex::then(
+                                      [=]
+                                      {
+                                        if (is_on_gpu())
+                                        {
+                                          flags.set();
+                                        }
+                                      }));
     cudaDeviceSynchronize();
 
     REQUIRE(flags_storage.all_set_once());
@@ -31,11 +37,12 @@ namespace {
     STDEXEC::sync_wait(std::move(snd));
   }
 
-  TEST_CASE("nvexec ensure_started propagates values", "[cuda][stream][adaptors][ensure_started]") {
+  TEST_CASE("nvexec ensure_started propagates values", "[cuda][stream][adaptors][ensure_started]")
+  {
     nvexec::stream_context stream_ctx{};
 
-    auto snd1 = exec::ensure_started(
-      ex::schedule(stream_ctx.get_scheduler()) | ex::then([]() -> bool { return is_on_gpu(); }));
+    auto snd1 = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler())
+                                     | ex::then([]() -> bool { return is_on_gpu(); }));
 
     auto snd2 = std::move(snd1)
               | ex::then([](bool prev_on_gpu) -> int { return prev_on_gpu && is_on_gpu(); });
@@ -45,68 +52,86 @@ namespace {
     REQUIRE(v == 1);
   }
 
-  TEST_CASE(
-    "ensure_started can preceed a sender without values",
-    "[cuda][stream][adaptors][ensure_started]") {
+  TEST_CASE("ensure_started can preceed a sender without values",
+            "[cuda][stream][adaptors][ensure_started]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler()) | ex::then([flags] {
-                                      if (is_on_gpu()) {
-                                        flags.set(0);
-                                      }
-                                    }))
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+    auto               flags = flags_storage.get();
+
+    auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler())
+                                    | ex::then(
+                                      [flags]
+                                      {
+                                        if (is_on_gpu())
+                                        {
+                                          flags.set(0);
+                                        }
+                                      }))
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec ensure_started can succeed a sender",
-    "[cuda][stream][adaptors][ensure_started]") {
-    SECTION("without values") {
+  TEST_CASE("nvexec ensure_started can succeed a sender",
+            "[cuda][stream][adaptors][ensure_started]")
+  {
+    SECTION("without values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t<2> flags_storage{};
-      auto flags = flags_storage.get();
-
-      auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler()) | a_sender([flags] {
-                                        if (is_on_gpu()) {
-                                          flags.set(1);
-                                        }
-                                      }))
-               | ex::then([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(0);
-                   }
-                 });
+      flags_storage_t<2>     flags_storage{};
+      auto                   flags = flags_storage.get();
+
+      auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler())
+                                      | a_sender(
+                                        [flags]
+                                        {
+                                          if (is_on_gpu())
+                                          {
+                                            flags.set(1);
+                                          }
+                                        }))
+               | ex::then(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(0);
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd));
 
       REQUIRE(flags_storage.all_set_once());
     }
 
-    SECTION("with values") {
+    SECTION("with values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t flags_storage{};
-      auto flags = flags_storage.get();
-
-      auto snd = exec::ensure_started(
-                   ex::schedule(stream_ctx.get_scheduler())
-                   | a_sender([]() -> bool { return is_on_gpu(); }))
-               | ex::then([flags](bool a_sender_was_on_gpu) {
-                   if (a_sender_was_on_gpu && is_on_gpu()) {
-                     flags.set();
-                   }
-                 });
+      flags_storage_t        flags_storage{};
+      auto                   flags = flags_storage.get();
+
+      auto snd = exec::ensure_started(ex::schedule(stream_ctx.get_scheduler())
+                                      | a_sender([]() -> bool { return is_on_gpu(); }))
+               | ex::then(
+                   [flags](bool a_sender_was_on_gpu)
+                   {
+                     if (a_sender_was_on_gpu && is_on_gpu())
+                     {
+                       flags.set();
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd)).value();
 
       REQUIRE(flags_storage.all_set_once());
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/launch.cpp b/test/nvexec/launch.cpp
index 425c6b9aa..d33e9e693 100644
--- a/test/nvexec/launch.cpp
+++ b/test/nvexec/launch.cpp
@@ -32,60 +32,71 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace { namespace {
-  constexpr std::size_t N = 2ul * 1024;
-  constexpr std::size_t THREAD_BLOCK_SIZE = 128u;
-  constexpr std::size_t NUM_BLOCKS = (N + THREAD_BLOCK_SIZE - 1) / THREAD_BLOCK_SIZE;
+namespace
+{
+  namespace
+  {
+    constexpr std::size_t N                 = 2ul * 1024;
+    constexpr std::size_t THREAD_BLOCK_SIZE = 128u;
+    constexpr std::size_t NUM_BLOCKS        = (N + THREAD_BLOCK_SIZE - 1) / THREAD_BLOCK_SIZE;
 
 #define scaling 2
 
-  auto bench() -> int {
-    std::vector<int> input(N, 0);
-    std::iota(input.begin(), input.end(), 1);
-    std::ranges::transform(input, input.begin(), [](int i) { return i * scaling; });
-    return std::accumulate(input.begin(), input.end(), 0);
-  }
-
-  TEST_CASE("nvexec launch executes on GPU", "[cuda][stream][adaptors][launch]") {
-    thrust::device_vector<int> input(N, 0);
-    std::iota(input.begin(), input.end(), 1);
-
-    int* first = thrust::raw_pointer_cast(input.data());
-    int* last = first + input.size();
-
-    nvexec::stream_context stream{};
-
-    flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = STDEXEC::just(first, last) | STDEXEC::continues_on(stream.get_scheduler())
-             | nvexec::launch(
-                 {.grid_size = NUM_BLOCKS, .block_size = THREAD_BLOCK_SIZE},
-                 [flags](cudaStream_t, int* first, int* last) -> void {
-                   const size_t idx = blockIdx.x * blockDim.x + threadIdx.x;
-                   const ptrdiff_t size = last - first;
-
-                   // this should be executing on the GPU
-                   if (idx == 0 && nvexec::is_on_gpu()) {
-                     flags.set(0);
-                   }
-
-                   if (idx < size) {
-                     first[idx] *= scaling;
-                   }
-                 })
-             | STDEXEC::then([flags](int* first, int* last) -> int {
-                 printf("In then() size=%d\n", (int) (last - first));
-                 if (nvexec::is_on_gpu()) {
-                   flags.set(1);
-                 }
-                 return std::accumulate(first, last, 0);
-               });
-
-    auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
-
-    REQUIRE(result == bench());
-    REQUIRE(flags_storage.all_set_once());
-  }
-
-}} // namespace
+    auto bench() -> int
+    {
+      std::vector<int> input(N, 0);
+      std::iota(input.begin(), input.end(), 1);
+      std::ranges::transform(input, input.begin(), [](int i) { return i * scaling; });
+      return std::accumulate(input.begin(), input.end(), 0);
+    }
+
+    TEST_CASE("nvexec launch executes on GPU", "[cuda][stream][adaptors][launch]")
+    {
+      thrust::device_vector<int> input(N, 0);
+      std::iota(input.begin(), input.end(), 1);
+
+      int* first = thrust::raw_pointer_cast(input.data());
+      int* last  = first + input.size();
+
+      nvexec::stream_context stream{};
+
+      flags_storage_t<2> flags_storage{};
+      auto               flags = flags_storage.get();
+
+      auto snd = STDEXEC::just(first, last) | STDEXEC::continues_on(stream.get_scheduler())
+               | nvexec::launch({.grid_size = NUM_BLOCKS, .block_size = THREAD_BLOCK_SIZE},
+                                [flags](cudaStream_t, int* first, int* last) -> void
+                                {
+                                  size_t const    idx  = blockIdx.x * blockDim.x + threadIdx.x;
+                                  ptrdiff_t const size = last - first;
+
+                                  // this should be executing on the GPU
+                                  if (idx == 0 && nvexec::is_on_gpu())
+                                  {
+                                    flags.set(0);
+                                  }
+
+                                  if (idx < size)
+                                  {
+                                    first[idx] *= scaling;
+                                  }
+                                })
+               | STDEXEC::then(
+                   [flags](int* first, int* last) -> int
+                   {
+                     printf("In then() size=%d\n", (int) (last - first));
+                     if (nvexec::is_on_gpu())
+                     {
+                       flags.set(1);
+                     }
+                     return std::accumulate(first, last, 0);
+                   });
+
+      auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+
+      REQUIRE(result == bench());
+      REQUIRE(flags_storage.all_set_once());
+    }
+
+  }  // namespace
+}  // namespace
diff --git a/test/nvexec/let_error.cpp b/test/nvexec/let_error.cpp
index 57370c863..9424e7b50 100644
--- a/test/nvexec/let_error.cpp
+++ b/test/nvexec/let_error.cpp
@@ -9,9 +9,11 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec let_error returns a sender", "[cuda][stream][adaptors][let_error]") {
+  TEST_CASE("nvexec let_error returns a sender", "[cuda][stream][adaptors][let_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
@@ -20,69 +22,84 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("nvexec let_error executes on GPU", "[cuda][stream][adaptors][let_error]") {
+  TEST_CASE("nvexec let_error executes on GPU", "[cuda][stream][adaptors][let_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::let_error([=](int err) {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set();
-                 }
-
-                 return ex::just()
-                      | exec::write_attrs(ex::prop{ex::get_domain, nvexec::stream_domain()});
-               });
+             | ex::let_error(
+                 [=](int err)
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set();
+                   }
+
+                   return ex::just()
+                        | exec::write_attrs(ex::prop{ex::get_domain, nvexec::stream_domain()});
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec let_error can preceed a sender without values",
-    "[cuda][stream][adaptors][let_error]") {
+  TEST_CASE("nvexec let_error can preceed a sender without values",
+            "[cuda][stream][adaptors][let_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::let_error([flags](int err) {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set(0);
-                 }
-
-                 return ex::just()
-                      | exec::write_attrs(ex::prop{ex::get_domain, nvexec::stream_domain()});
-               })
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+             | ex::let_error(
+                 [flags](int err)
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set(0);
+                   }
+
+                   return ex::just()
+                        | exec::write_attrs(ex::prop{ex::get_domain, nvexec::stream_domain()});
+                 })
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_error can succeed a sender", "[cuda][stream][adaptors][let_error]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec let_error can succeed a sender", "[cuda][stream][adaptors][let_error]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler sch = stream_ctx.get_scheduler();
-    flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    flags_storage_t          flags_storage{};
+    auto                     flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | a_sender([]() noexcept { }) | ex::let_error([=](int err) {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set();
-                 }
-
-                 return ex::schedule(sch);
-               });
+             | a_sender([]() noexcept {})
+             | ex::let_error(
+                 [=](int err)
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set();
+                   }
+
+                   return ex::schedule(sch);
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/let_stopped.cpp b/test/nvexec/let_stopped.cpp
index 301962a7b..2b3eb786d 100644
--- a/test/nvexec/let_stopped.cpp
+++ b/test/nvexec/let_stopped.cpp
@@ -8,9 +8,11 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec let_stopped returns a sender", "[cuda][stream][adaptors][let_stopped]") {
+  TEST_CASE("nvexec let_stopped returns a sender", "[cuda][stream][adaptors][let_stopped]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::just_stopped() | ex::continues_on(stream_ctx.get_scheduler())
@@ -19,68 +21,82 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("nvexec let_stopped executes on GPU", "[cuda][stream][adaptors][let_stopped]") {
+  TEST_CASE("nvexec let_stopped executes on GPU", "[cuda][stream][adaptors][let_stopped]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just_stopped() | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::let_stopped([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-
-                 return ex::just();
-               });
+             | ex::let_stopped(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+
+                   return ex::just();
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec let_stopped can preceed a sender without values",
-    "[cuda][stream][adaptors][let_stopped]") {
+  TEST_CASE("nvexec let_stopped can preceed a sender without values",
+            "[cuda][stream][adaptors][let_stopped]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
     auto snd = ex::just_stopped() | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::let_stopped([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(0);
-                 }
-
-                 return ex::just();
-               })
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+             | ex::let_stopped(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(0);
+                   }
+
+                   return ex::just();
+                 })
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_stopped can succeed a sender", "[cuda][stream][adaptors][let_stopped]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec let_stopped can succeed a sender", "[cuda][stream][adaptors][let_stopped]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler sch = stream_ctx.get_scheduler();
-    flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    flags_storage_t          flags_storage{};
+    auto                     flags = flags_storage.get();
 
-    auto snd = ex::just_stopped() | ex::continues_on(sch) | a_sender([]() noexcept { })
-             | ex::let_stopped([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
+    auto snd = ex::just_stopped() | ex::continues_on(sch) | a_sender([]() noexcept {})
+             | ex::let_stopped(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
 
-                 return ex::schedule(sch);
-               });
+                   return ex::schedule(sch);
+                 });
 
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/let_value.cpp b/test/nvexec/let_value.cpp
index e9baa16a6..9f45682c0 100644
--- a/test/nvexec/let_value.cpp
+++ b/test/nvexec/let_value.cpp
@@ -8,143 +8,176 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec let_value returns a sender", "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value returns a sender", "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
     auto snd = ex::let_value(ex::schedule(stream_ctx.get_scheduler()), [] { return ex::just(); });
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec let_value executes on GPU", "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value executes on GPU", "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::let_value([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-                 return ex::just();
-               });
+    auto            flags = flags_storage.get();
+
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::let_value(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+                   return ex::just();
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_value accepts values on GPU", "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value accepts values on GPU", "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::then([]() -> int { return 42; })
-             | ex::let_value([=](int val) {
-                 if (is_on_gpu()) {
-                   if (val == 42) {
-                     flags.set();
+             | ex::let_value(
+                 [=](int val)
+                 {
+                   if (is_on_gpu())
+                   {
+                     if (val == 42)
+                     {
+                       flags.set();
+                     }
                    }
-                 }
-                 return ex::just();
-               });
+                   return ex::just();
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec let_value accepts multiple values on GPU",
-    "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value accepts multiple values on GPU",
+            "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just(42, 4.2) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::let_value([=](int i, double d) {
-                 if (is_on_gpu()) {
-                   if (i == 42 && d == 4.2) {
-                     flags.set();
+             | ex::let_value(
+                 [=](int i, double d)
+                 {
+                   if (is_on_gpu())
+                   {
+                     if (i == 42 && d == 4.2)
+                     {
+                       flags.set();
+                     }
                    }
-                 }
-                 return ex::just();
-               });
+                   return ex::just();
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_value returns values on GPU", "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value returns values on GPU", "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::schedule(stream_ctx.get_scheduler())
              | ex::let_value([=]() { return ex::just(is_on_gpu()); });
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(result == 1);
   }
 
-  TEST_CASE(
-    "nvexec let_value can preceed a sender without values",
-    "[cuda][stream][adaptors][let_value]") {
+  TEST_CASE("nvexec let_value can preceed a sender without values",
+            "[cuda][stream][adaptors][let_value]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::let_value([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(0);
-                 }
-
-                 return ex::just();
-               })
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+    auto               flags = flags_storage.get();
+
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::let_value(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(0);
+                   }
+
+                   return ex::just();
+                 })
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_value can succeed a sender", "[cuda][stream][adaptors][let_value]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec let_value can succeed a sender", "[cuda][stream][adaptors][let_value]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler sch = stream_ctx.get_scheduler();
-    flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::schedule(sch) | a_sender([]() noexcept { }) | ex::let_value([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
+    flags_storage_t          flags_storage{};
+    auto                     flags = flags_storage.get();
+
+    auto snd = ex::schedule(sch) | a_sender([]() noexcept {})
+             | ex::let_value(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
 
-                 return ex::schedule(sch);
-               });
+                   return ex::schedule(sch);
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec let_value can read a property", "[cuda][stream][adaptors][let_value]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec let_value can read a property", "[cuda][stream][adaptors][let_value]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler sch = stream_ctx.get_scheduler();
-    flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    flags_storage_t          flags_storage{};
+    auto                     flags = flags_storage.get();
 
     auto snd = ex::schedule(sch) | ex::let_value([] { return nvexec::get_stream(); })
-             | ex::then([flags](cudaStream_t stream) {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-                 return stream;
-               });
+             | ex::then(
+                 [flags](cudaStream_t stream)
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+                   return stream;
+                 });
     auto [stream] = STDEXEC::sync_wait(std::move(snd)).value();
     static_assert(std::same_as<decltype(+stream), cudaStream_t>);
 
     REQUIRE(flags_storage.all_set_once());
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/monotonic_buffer.cpp b/test/nvexec/monotonic_buffer.cpp
index ebc6bc7e3..ca28e2172 100644
--- a/test/nvexec/monotonic_buffer.cpp
+++ b/test/nvexec/monotonic_buffer.cpp
@@ -4,9 +4,11 @@
 #include "nvexec/detail/memory.cuh"
 #include "tracer_resource.h"
 
-namespace {
+namespace
+{
 
-  TEST_CASE("monotonic buffer releases storage", "[cuda][stream][memory][monotonic buffer]") {
+  TEST_CASE("monotonic buffer releases storage", "[cuda][stream][memory][monotonic buffer]")
+  {
     tracer_resource resource{};
 
     {
@@ -27,9 +29,9 @@ namespace {
     REQUIRE(0 == resource.allocations.size());
   }
 
-  TEST_CASE(
-    "monotonic buffer keeps track of new allocations",
-    "[cuda][stream][memory][monotonic buffer]") {
+  TEST_CASE("monotonic buffer keeps track of new allocations",
+            "[cuda][stream][memory][monotonic buffer]")
+  {
     tracer_resource resource{};
 
     {
@@ -58,10 +60,10 @@ namespace {
     REQUIRE(0 == resource.allocations.size());
   }
 
-  TEST_CASE(
-    "monotonic buffer provides required allocations",
-    "[cuda][stream][memory][monotonic buffer]") {
-    tracer_resource resource{};
+  TEST_CASE("monotonic buffer provides required allocations",
+            "[cuda][stream][memory][monotonic buffer]")
+  {
+    tracer_resource                     resource{};
     nvdetail::monotonic_buffer_resource buffer{1024, &resource};
 
     char* ptr_1 = reinterpret_cast<char*>(buffer.allocate(32, 8));
@@ -74,16 +76,17 @@ namespace {
     buffer.deallocate(ptr_2, 32, 16);
   }
 
-  TEST_CASE(
-    "monotonic buffer provides required alignment",
-    "[cuda][stream][memory][monotonic buffer]") {
-    tracer_resource resource{};
+  TEST_CASE("monotonic buffer provides required alignment",
+            "[cuda][stream][memory][monotonic buffer]")
+  {
+    tracer_resource                     resource{};
     nvdetail::monotonic_buffer_resource buffer{2048, &resource};
 
-    for (int alignment = 1; alignment < 512; alignment *= 2) {
+    for (int alignment = 1; alignment < 512; alignment *= 2)
+    {
       void* ptr = buffer.allocate(32, alignment);
       REQUIRE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
       buffer.deallocate(ptr, 32, alignment);
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/reduce.cpp b/test/nvexec/reduce.cpp
index f5cc6072d..f1c2989e4 100644
--- a/test/nvexec/reduce.cpp
+++ b/test/nvexec/reduce.cpp
@@ -12,20 +12,22 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  struct minimum {
+namespace
+{
+  struct minimum
+  {
     template <class T1, class T2>
     constexpr auto
-      operator()(const T1& lhs, const T2& rhs) const -> ::cuda::std::common_type_t<T1, T2> {
+    operator()(const T1& lhs, const T2& rhs) const -> ::cuda::std::common_type_t<T1, T2>
+    {
       return (lhs < rhs) ? lhs : rhs;
     }
   };
 
-  TEST_CASE(
-    "nvexec reduce returns a sender with single input",
-    "[cuda][stream][adaptors][reduce]") {
-    constexpr int N = 2048;
-    int input[N] = {};
+  TEST_CASE("nvexec reduce returns a sender with single input", "[cuda][stream][adaptors][reduce]")
+  {
+    constexpr int N        = 2048;
+    int           input[N] = {};
     std::fill_n(input, N, 1);
 
     nvexec::stream_context stream{};
@@ -37,9 +39,10 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("nvexec reduce returns a sender with two inputs", "[cuda][stream][adaptors][reduce]") {
-    constexpr int N = 2048;
-    int input[N] = {};
+  TEST_CASE("nvexec reduce returns a sender with two inputs", "[cuda][stream][adaptors][reduce]")
+  {
+    constexpr int N        = 2048;
+    int           input[N] = {};
     std::fill_n(input, N, 1);
 
     nvexec::stream_context stream{};
@@ -51,13 +54,14 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("nvexec reduce uses sum as default", "[cuda][stream][adaptors][reduce]") {
-    constexpr int N = 2048;
+  TEST_CASE("nvexec reduce uses sum as default", "[cuda][stream][adaptors][reduce]")
+  {
+    constexpr int N    = 2048;
     constexpr int init = 42;
 
     thrust::device_vector<int> input(N, 1);
-    int* first = thrust::raw_pointer_cast(input.data());
-    int* last = thrust::raw_pointer_cast(input.data()) + input.size();
+    int*                       first = thrust::raw_pointer_cast(input.data());
+    int*                       last  = thrust::raw_pointer_cast(input.data()) + input.size();
 
     nvexec::stream_context stream{};
     auto snd = ex::just(std::span{first, last}) | ex::continues_on(stream.get_scheduler())
@@ -68,13 +72,14 @@ namespace {
     REQUIRE(result == N + init);
   }
 
-  TEST_CASE("nvexec reduce uses the passed function", "[cuda][stream][adaptors][reduce]") {
-    constexpr int N = 2048;
+  TEST_CASE("nvexec reduce uses the passed function", "[cuda][stream][adaptors][reduce]")
+  {
+    constexpr int N    = 2048;
     constexpr int init = 42;
 
     thrust::device_vector<int> input(N, 1);
-    int* first = thrust::raw_pointer_cast(input.data());
-    int* last = thrust::raw_pointer_cast(input.data()) + input.size();
+    int*                       first = thrust::raw_pointer_cast(input.data());
+    int*                       last  = thrust::raw_pointer_cast(input.data()) + input.size();
 
     nvexec::stream_context stream{};
     auto snd = ex::just(std::span{first, last}) | ex::continues_on(stream.get_scheduler())
@@ -85,15 +90,17 @@ namespace {
     REQUIRE(result == 1);
   }
 
-  TEST_CASE("nvexec reduce executes on GPU", "[cuda][stream][adaptors][reduce]") {
-    constexpr int N = 2048;
+  TEST_CASE("nvexec reduce executes on GPU", "[cuda][stream][adaptors][reduce]")
+  {
+    constexpr int N    = 2048;
     constexpr int init = 42;
 
     thrust::device_vector<int> input(N, 1);
-    int* first = thrust::raw_pointer_cast(input.data());
-    int* last = thrust::raw_pointer_cast(input.data()) + input.size();
+    int*                       first = thrust::raw_pointer_cast(input.data());
+    int*                       last  = thrust::raw_pointer_cast(input.data()) + input.size();
 
-    auto is_on_gpu = [](const int left, const int right) {
+    auto is_on_gpu = [](int const left, int const right)
+    {
       return nvexec::is_on_gpu() ? left + right : 0;
     };
 
@@ -105,4 +112,4 @@ namespace {
 
     REQUIRE(result == N + init);
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/split.cpp b/test/nvexec/split.cpp
index e159e6176..9f64a6192 100644
--- a/test/nvexec/split.cpp
+++ b/test/nvexec/split.cpp
@@ -8,16 +8,19 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec split returns a sender", "[cuda][stream][adaptors][split]") {
+  TEST_CASE("nvexec split returns a sender", "[cuda][stream][adaptors][split]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto snd = exec::split(ex::schedule(stream_ctx.get_scheduler()));
+    auto                   snd = exec::split(ex::schedule(stream_ctx.get_scheduler()));
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec split works", "[cuda][stream][adaptors][split]") {
+  TEST_CASE("nvexec split works", "[cuda][stream][adaptors][split]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto fork = ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] { return is_on_gpu(); })
@@ -33,59 +36,78 @@ namespace {
     REQUIRE(v2 == 42);
   }
 
-  TEST_CASE("nvexec split can preceed a sender without values", "[cuda][stream][adaptors][split]") {
+  TEST_CASE("nvexec split can preceed a sender without values", "[cuda][stream][adaptors][split]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | exec::split() | a_sender([=]() noexcept {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-               });
+    auto            flags = flags_storage.get();
+
+    auto snd = ex::schedule(stream_ctx.get_scheduler()) | exec::split()
+             | a_sender(
+                 [=]() noexcept
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+                 });
 
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec split can succeed a sender", "[cuda][stream][adaptors][split]") {
-    SECTION("without values") {
+  TEST_CASE("nvexec split can succeed a sender", "[cuda][stream][adaptors][split]")
+  {
+    SECTION("without values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t<2> flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t<2>     flags_storage{};
+      auto                   flags = flags_storage.get();
 
-      auto snd = ex::schedule(stream_ctx.get_scheduler()) | a_sender([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(1);
-                   }
-                 })
-               | exec::split() | ex::then([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(0);
-                   }
-                 });
+      auto snd = ex::schedule(stream_ctx.get_scheduler())
+               | a_sender(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(1);
+                     }
+                   })
+               | exec::split()
+               | ex::then(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(0);
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd));
 
       REQUIRE(flags_storage.all_set_once());
     }
 
-    SECTION("with values") {
+    SECTION("with values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t        flags_storage{};
+      auto                   flags = flags_storage.get();
 
       auto snd = ex::schedule(stream_ctx.get_scheduler())
                | a_sender([]() -> bool { return is_on_gpu(); }) | exec::split()
-               | ex::then([flags](bool a_sender_was_on_gpu) {
-                   if (a_sender_was_on_gpu && is_on_gpu()) {
-                     flags.set();
-                   }
-                 });
+               | ex::then(
+                   [flags](bool a_sender_was_on_gpu)
+                   {
+                     if (a_sender_was_on_gpu && is_on_gpu())
+                     {
+                       flags.set();
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd)).value();
 
       REQUIRE(flags_storage.all_set_once());
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/start_detached.cpp b/test/nvexec/start_detached.cpp
index b5bb84447..70139cdc5 100644
--- a/test/nvexec/start_detached.cpp
+++ b/test/nvexec/start_detached.cpp
@@ -4,7 +4,7 @@
 
 #include "common.cuh"
 #include "exec/start_detached.hpp"
-#include "nvexec/detail/cuda_atomic.cuh" // IWYU pragma: keep
+#include "nvexec/detail/cuda_atomic.cuh"  // IWYU pragma: keep
 #include "nvexec/stream/common.cuh"
 #include "nvexec/stream_context.cuh"
 
@@ -12,12 +12,16 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec start_detached doesn't block", "[cuda][stream][consumers][start_detached]") {
-    if (const char* env = std::getenv("CUDA_LAUNCH_BLOCKING")) {
-      if (std::strlen(env) >= 1 && env[0] == '1') {
-        return; // This test is unable to run when the launch is blocking
+  TEST_CASE("nvexec start_detached doesn't block", "[cuda][stream][consumers][start_detached]")
+  {
+    if (char const * env = std::getenv("CUDA_LAUNCH_BLOCKING"))
+    {
+      if (std::strlen(env) >= 1 && env[0] == '1')
+      {
+        return;  // This test is unable to run when the launch is blocking
       }
     }
 
@@ -29,18 +33,23 @@ namespace {
     STDEXEC_TRY_CUDA_API(cudaMallocHost(&device_flag, sizeof(int)));
     *host_flag = *device_flag = 0;
 
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] {
-                 if (is_on_gpu()) {
-                   cuda::atomic_ref<int, cuda::thread_scope_system> host_flag_ref(*host_flag);
-                   cuda::atomic_ref<int, cuda::thread_scope_system> device_flag_ref(*device_flag);
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::then(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     cuda::atomic_ref<int, cuda::thread_scope_system> host_flag_ref(*host_flag);
+                     cuda::atomic_ref<int, cuda::thread_scope_system> device_flag_ref(*device_flag);
 
-                   int iteration{1};
-                   while (host_flag_ref.load(cuda::memory_order_relaxed) == 0) {
-                     iteration++;
+                     int iteration{1};
+                     while (host_flag_ref.load(cuda::memory_order_relaxed) == 0)
+                     {
+                       iteration++;
+                     }
+                     device_flag_ref.store(iteration, cuda::memory_order_relaxed);
                    }
-                   device_flag_ref.store(iteration, cuda::memory_order_relaxed);
-                 }
-               });
+                 });
 
     // then won't complete until we set flag, so if the `start_detached` is blocking, we'll deadlock
     exec::start_detached(std::move(snd));
@@ -57,4 +66,4 @@ namespace {
     STDEXEC_TRY_CUDA_API(cudaFreeHost(host_flag));
     STDEXEC_TRY_CUDA_API(cudaFreeHost(device_flag));
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/synchronized_pool.cpp b/test/nvexec/synchronized_pool.cpp
index 38bc1ecf2..a8e586773 100644
--- a/test/nvexec/synchronized_pool.cpp
+++ b/test/nvexec/synchronized_pool.cpp
@@ -4,9 +4,11 @@
 #include "nvexec/detail/memory.cuh"
 #include "tracer_resource.h"
 
-namespace {
+namespace
+{
 
-  TEST_CASE("synchronized pool releases storage", "[cuda][stream][memory][synchronized pool]") {
+  TEST_CASE("synchronized pool releases storage", "[cuda][stream][memory][synchronized pool]")
+  {
     tracer_resource resource{};
 
     {
@@ -27,13 +29,15 @@ namespace {
     REQUIRE(0 == resource.allocations.size());
   }
 
-  TEST_CASE("synchronized pool caches allocations", "[cuda][stream][memory][synchronized pool]") {
+  TEST_CASE("synchronized pool caches allocations", "[cuda][stream][memory][synchronized pool]")
+  {
     tracer_resource resource{};
 
     {
       nvdetail::synchronized_pool_resource pool{&resource};
 
-      for (int i = 0; i < 10; i++) {
+      for (int i = 0; i < 10; i++)
+      {
         void* ptr_1 = pool.allocate(128, 8);
         void* ptr_2 = pool.allocate(256, 16);
         REQUIRE(ptr_1 != nullptr);
@@ -52,14 +56,15 @@ namespace {
     REQUIRE(0 == resource.allocations.size());
   }
 
-  TEST_CASE(
-    "synchronized pool doesn't touch allocated memory",
-    "[cuda][stream][memory][synchronized pool]") {
-    tracer_resource resource{};
+  TEST_CASE("synchronized pool doesn't touch allocated memory",
+            "[cuda][stream][memory][synchronized pool]")
+  {
+    tracer_resource                      resource{};
     nvdetail::synchronized_pool_resource pool{&resource};
 
-    for (int n = 32; n < 512; n *= 2) {
-      int bytes = n * sizeof(int);
+    for (int n = 32; n < 512; n *= 2)
+    {
+      int bytes     = n * sizeof(int);
       int alignment = alignof(int);
 
       int* ptr = reinterpret_cast<int*>(pool.allocate(bytes, alignment));
@@ -67,24 +72,26 @@ namespace {
       pool.deallocate(ptr, 128, 8);
 
       ptr = reinterpret_cast<int*>(pool.allocate(bytes, alignment));
-      for (int i = 0; i < n; i++) {
+      for (int i = 0; i < n; i++)
+      {
         REQUIRE(ptr[i] == i + n);
       }
       pool.deallocate(ptr, 128, 8);
     }
   }
 
-  TEST_CASE(
-    "synchronized pool provides required alignment",
-    "[cuda][stream][memory][synchronized pool]") {
-    tracer_resource resource{};
+  TEST_CASE("synchronized pool provides required alignment",
+            "[cuda][stream][memory][synchronized pool]")
+  {
+    tracer_resource                      resource{};
     nvdetail::synchronized_pool_resource pool{&resource};
 
-    for (int alignment = 1; alignment < 512; alignment *= 2) {
+    for (int alignment = 1; alignment < 512; alignment *= 2)
+    {
       void* ptr = pool.allocate(32, alignment);
       INFO("Alignment: " << alignment);
       REQUIRE(reinterpret_cast<uintptr_t>(ptr) % alignment == 0);
       pool.deallocate(ptr, 32, alignment);
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/then.cpp b/test/nvexec/then.cpp
index d697d6881..e6aeaf55f 100644
--- a/test/nvexec/then.cpp
+++ b/test/nvexec/then.cpp
@@ -9,236 +9,300 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec then returns a sender", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then returns a sender", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto snd = ex::then(ex::schedule(stream_ctx.get_scheduler()), [] { });
+    auto                   snd = ex::then(ex::schedule(stream_ctx.get_scheduler()), [] {});
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec then executes on GPU", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then executes on GPU", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-               });
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::then(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec then accepts values on GPU", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then accepts values on GPU", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::just(42) | ex::continues_on(stream_ctx.get_scheduler()) | ex::then([=](int val) {
-                 if (is_on_gpu()) {
-                   if (val == 42) {
-                     flags.set();
+    auto            flags = flags_storage.get();
+
+    auto snd = ex::just(42) | ex::continues_on(stream_ctx.get_scheduler())
+             | ex::then(
+                 [=](int val)
+                 {
+                   if (is_on_gpu())
+                   {
+                     if (val == 42)
+                     {
+                       flags.set();
+                     }
                    }
-                 }
-               });
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec then accepts multiple values on GPU", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then accepts multiple values on GPU", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just(42, 4.2) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::then([=](int i, double d) {
-                 if (is_on_gpu()) {
-                   if (i == 42 && d == 4.2) {
-                     flags.set();
+             | ex::then(
+                 [=](int i, double d)
+                 {
+                   if (is_on_gpu())
+                   {
+                     if (i == 42 && d == 4.2)
+                     {
+                       flags.set();
+                     }
                    }
-                 }
-               });
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec then returns values on GPU", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then returns values on GPU", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::then([=]() -> int {
-                 if (is_on_gpu()) {
-                   return 42;
-                 }
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::then(
+                 [=]() -> int
+                 {
+                   if (is_on_gpu())
+                   {
+                     return 42;
+                   }
 
-                 return 0;
-               });
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+                   return 0;
+                 });
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(result == 42);
   }
 
-  TEST_CASE("nvexec then can preceed a sender without values", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then can preceed a sender without values", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::schedule(stream_ctx.get_scheduler()) | ex::then([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(0);
-                 }
-               })
-             | a_sender([flags] {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+    auto               flags = flags_storage.get();
+
+    auto snd = ex::schedule(stream_ctx.get_scheduler())
+             | ex::then(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(0);
+                   }
+                 })
+             | a_sender(
+                 [flags]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec then can succeed a sender", "[cuda][stream][adaptors][then]") {
-    SECTION("without values") {
+  TEST_CASE("nvexec then can succeed a sender", "[cuda][stream][adaptors][then]")
+  {
+    SECTION("without values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t<2> flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t<2>     flags_storage{};
+      auto                   flags = flags_storage.get();
 
-      auto snd = ex::schedule(stream_ctx.get_scheduler()) | a_sender([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(1);
-                   }
-                 })
-               | ex::then([flags] {
-                   if (is_on_gpu()) {
-                     flags.set(0);
-                   }
-                 });
+      auto snd = ex::schedule(stream_ctx.get_scheduler())
+               | a_sender(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(1);
+                     }
+                   })
+               | ex::then(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set(0);
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd));
 
       REQUIRE(flags_storage.all_set_once());
     }
 
-    SECTION("with values") {
+    SECTION("with values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t        flags_storage{};
+      auto                   flags = flags_storage.get();
 
       auto snd = ex::schedule(stream_ctx.get_scheduler())
                | a_sender([]() -> bool { return is_on_gpu(); })
-               | ex::then([flags](bool a_sender_was_on_gpu) {
-                   if (a_sender_was_on_gpu && is_on_gpu()) {
-                     flags.set();
-                   }
-                 });
+               | ex::then(
+                   [flags](bool a_sender_was_on_gpu)
+                   {
+                     if (a_sender_was_on_gpu && is_on_gpu())
+                     {
+                       flags.set();
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd)).value();
 
       REQUIRE(flags_storage.all_set_once());
     }
   }
 
-  TEST_CASE("nvexec then can succeed a receiverless sender", "[cuda][stream][adaptors][then]") {
-    SECTION("without values") {
+  TEST_CASE("nvexec then can succeed a receiverless sender", "[cuda][stream][adaptors][then]")
+  {
+    SECTION("without values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t flags_storage{};
-      auto flags = flags_storage.get();
-
-      auto snd = ex::schedule(stream_ctx.get_scheduler()) | a_sender() | ex::then([flags] {
-                   if (is_on_gpu()) {
-                     flags.set();
-                   }
-                 });
+      flags_storage_t        flags_storage{};
+      auto                   flags = flags_storage.get();
+
+      auto snd = ex::schedule(stream_ctx.get_scheduler()) | a_sender()
+               | ex::then(
+                   [flags]
+                   {
+                     if (is_on_gpu())
+                     {
+                       flags.set();
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd));
 
       REQUIRE(flags_storage.all_set_once());
     }
 
-    SECTION("with values") {
+    SECTION("with values")
+    {
       nvexec::stream_context stream_ctx{};
-      flags_storage_t flags_storage{};
-      auto flags = flags_storage.get();
+      flags_storage_t        flags_storage{};
+      auto                   flags = flags_storage.get();
 
       auto snd = ex::schedule(stream_ctx.get_scheduler())
                | ex::then([]() -> bool { return is_on_gpu(); }) | a_sender()
-               | ex::then([flags](bool a_sender_was_on_gpu) {
-                   if (a_sender_was_on_gpu && is_on_gpu()) {
-                     flags.set();
-                   }
-                 });
+               | ex::then(
+                   [flags](bool a_sender_was_on_gpu)
+                   {
+                     if (a_sender_was_on_gpu && is_on_gpu())
+                     {
+                       flags.set();
+                     }
+                   });
       STDEXEC::sync_wait(std::move(snd)).value();
 
       REQUIRE(flags_storage.all_set_once());
     }
   }
 
-  TEST_CASE(
-    "nvexec then can return values of non-trivial types",
-    "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then can return values of non-trivial types", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
-    flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    flags_storage_t        flags_storage{};
+    auto                   flags = flags_storage.get();
 
     auto snd = ex::schedule(stream_ctx.get_scheduler())
              | ex::then([]() -> move_only_t { return move_only_t{42}; })
-             | ex::then([flags](move_only_t &&val) {
-                 if (val.contains(42)) {
-                   flags.set();
-                 }
-               });
+             | ex::then(
+                 [flags](move_only_t &&val)
+                 {
+                   if (val.contains(42))
+                   {
+                     flags.set();
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  class tracer_storage_t {
-    int h_counter_storage{};
+  class tracer_storage_t
+  {
+    int  h_counter_storage{};
     int *h_counter_{};
     int *d_counter_{};
 
    public:
     tracer_storage_t()
-      : h_counter_{&h_counter_storage} {
+      : h_counter_{&h_counter_storage}
+    {
       cudaMalloc(&d_counter_, sizeof(int));
       cudaMemset(d_counter_, 0, sizeof(int));
     }
 
-    ~tracer_storage_t() {
+    ~tracer_storage_t()
+    {
       cudaFree(d_counter_);
     }
 
-    class handle_t {
+    class handle_t
+    {
       int *h_counter_{};
       int *d_counter_{};
 
       handle_t(int *h_counter, int *d_counter)
         : h_counter_{h_counter}
-        , d_counter_{d_counter} {
-      }
+        , d_counter_{d_counter}
+      {}
 
-      __host__ __device__ void diff(int val) {
+      __host__ __device__ void diff(int val)
+      {
         cuda::std::atomic_ref<int> ref{*(is_on_gpu() ? d_counter_ : h_counter_)};
         ref.fetch_add(val, cuda::std::memory_order_relaxed);
       }
 
      public:
-      __host__ __device__ void more() {
+      __host__ __device__ void more()
+      {
         diff(+1);
       }
 
-      __host__ __device__ void fewer() {
+      __host__ __device__ void fewer()
+      {
         diff(-1);
       }
 
-      __host__ auto alive() -> int {
+      __host__ auto alive() -> int
+      {
         int d_counter{};
         cudaMemcpy(&d_counter, d_counter_, sizeof(int), cudaMemcpyDeviceToHost);
         return *h_counter_ + d_counter;
@@ -247,54 +311,64 @@ namespace {
       friend tracer_storage_t;
     };
 
-    auto get() -> handle_t {
+    auto get() -> handle_t
+    {
       return handle_t{h_counter_, d_counter_};
     }
   };
 
-  class tracer_t {
+  class tracer_t
+  {
     tracer_storage_t::handle_t handle_;
 
-    void print(const char *msg) {
-      if (is_on_gpu()) {
+    void print(char const *msg)
+    {
+      if (is_on_gpu())
+      {
         printf("gpu: %s\n", msg);
-      } else {
+      }
+      else
+      {
         printf("cpu: %s\n", msg);
       }
     }
 
    public:
-    tracer_t() = delete;
-    tracer_t(const tracer_t &other) = delete;
+    tracer_t()                      = delete;
+    tracer_t(tracer_t const &other) = delete;
 
     __host__ __device__ tracer_t(tracer_storage_t::handle_t handle)
-      : handle_(handle) {
+      : handle_(handle)
+    {
       handle_.more();
     }
 
     __host__ __device__ tracer_t(tracer_t &&other)
-      : handle_(other.handle_) {
+      : handle_(other.handle_)
+    {
       handle_.more();
     }
 
-    __host__ __device__ ~tracer_t() {
+    __host__ __device__ ~tracer_t()
+    {
       handle_.fewer();
     }
   };
 
-  TEST_CASE("nvexec then destructs temporary storage", "[cuda][stream][adaptors][then]") {
+  TEST_CASE("nvexec then destructs temporary storage", "[cuda][stream][adaptors][then]")
+  {
     nvexec::stream_context stream_ctx{};
 
-    tracer_storage_t storage;
+    tracer_storage_t           storage;
     tracer_storage_t::handle_t handle = storage.get();
 
     {
       auto snd = ex::schedule(stream_ctx.get_scheduler())
                | ex::then([handle]() -> tracer_t { return tracer_t{handle}; })
-               | ex::then([](tracer_t &&) { });
+               | ex::then([](tracer_t &&) {});
       STDEXEC::sync_wait(std::move(snd));
     }
 
     REQUIRE(handle.alive() == 0);
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/transfer.cpp b/test/nvexec/transfer.cpp
index 12c18b7e2..4f64b5c8d 100644
--- a/test/nvexec/transfer.cpp
+++ b/test/nvexec/transfer.cpp
@@ -9,140 +9,155 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE(
-    "nvexec continues_on to stream context returns a sender",
-    "[cuda][stream][adaptors][continues_on]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec continues_on to stream context returns a sender",
+            "[cuda][stream][adaptors][continues_on]")
+  {
+    nvexec::stream_context      stream_ctx{};
     exec::single_thread_context cpu_ctx{};
-    auto cpu = cpu_ctx.get_scheduler();
-    nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
+    auto                        cpu = cpu_ctx.get_scheduler();
+    nvexec::stream_scheduler    gpu = stream_ctx.get_scheduler();
 
     auto snd = ex::schedule(cpu) | ex::continues_on(gpu);
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec continues_on from stream context returns a sender",
-    "[cuda][stream][adaptors][continues_on]") {
+  TEST_CASE("nvexec continues_on from stream context returns a sender",
+            "[cuda][stream][adaptors][continues_on]")
+  {
     nvexec::stream_context stream_ctx{};
 
     exec::single_thread_context cpu_ctx{};
-    auto cpu = cpu_ctx.get_scheduler();
-    nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
+    auto                        cpu = cpu_ctx.get_scheduler();
+    nvexec::stream_scheduler    gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::schedule(gpu) //
+    auto snd = ex::schedule(gpu)  //
              | ex::continues_on(cpu);
 
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec continues_on changes context to GPU",
-    "[cuda][stream][adaptors][continues_on]") {
+  TEST_CASE("nvexec continues_on changes context to GPU", "[cuda][stream][adaptors][continues_on]")
+  {
     nvexec::stream_context stream_ctx{};
 
     exec::single_thread_context cpu_ctx{};
-    auto cpu = cpu_ctx.get_scheduler();
-    nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
+    auto                        cpu = cpu_ctx.get_scheduler();
+    nvexec::stream_scheduler    gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::schedule(cpu) //
-             | ex::then([=] {
-                 if (!is_on_gpu()) {
-                   return 1;
-                 }
-                 return 0;
-               })
-             | ex::continues_on(gpu) //
-             | ex::then([=](int val) -> int {
-                 if (is_on_gpu() && val == 1) {
-                   return 2;
-                 }
-                 return 0;
-               });
-
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto snd = ex::schedule(cpu)  //
+             | ex::then(
+                 [=]
+                 {
+                   if (!is_on_gpu())
+                   {
+                     return 1;
+                   }
+                   return 0;
+                 })
+             | ex::continues_on(gpu)  //
+             | ex::then(
+                 [=](int val) -> int
+                 {
+                   if (is_on_gpu() && val == 1)
+                   {
+                     return 2;
+                   }
+                   return 0;
+                 });
+
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
     REQUIRE(result == 2);
   }
 
-  TEST_CASE(
-    "nvexec continues_on changes context from GPU",
-    "[cuda][stream][adaptors][continues_on]") {
+  TEST_CASE("nvexec continues_on changes context from GPU",
+            "[cuda][stream][adaptors][continues_on]")
+  {
     nvexec::stream_context stream_ctx{};
 
     exec::single_thread_context cpu_ctx{};
-    auto cpu = cpu_ctx.get_scheduler();
-    nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
+    auto                        cpu = cpu_ctx.get_scheduler();
+    nvexec::stream_scheduler    gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::schedule(gpu) //
-             | ex::then([=] {
-                 if (is_on_gpu()) {
-                   return 1;
-                 }
-                 return 0;
-               })
-             | ex::continues_on(cpu) //
-             | ex::then([=](int val) -> int {
-                 if (!is_on_gpu() && val == 1) {
-                   return 2;
-                 }
-                 return 0;
-               });
-
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto snd = ex::schedule(gpu)  //
+             | ex::then(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     return 1;
+                   }
+                   return 0;
+                 })
+             | ex::continues_on(cpu)  //
+             | ex::then(
+                 [=](int val) -> int
+                 {
+                   if (!is_on_gpu() && val == 1)
+                   {
+                     return 2;
+                   }
+                   return 0;
+                 });
+
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
     REQUIRE(result == 2);
   }
 
-  TEST_CASE(
-    "nvexec just/continues_on changes context to GPU",
-    "[cuda][stream][adaptors][continues_on]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec just/continues_on changes context to GPU",
+            "[cuda][stream][adaptors][continues_on]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::just(42) | ex::continues_on(gpu) //
-             | ex::then([=](auto i) {
-                 if (is_on_gpu() && i == 42) {
-                   return true;
-                 }
-                 return false;
-               });
-
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto snd = ex::just(42) | ex::continues_on(gpu)  //
+             | ex::then(
+                 [=](auto i)
+                 {
+                   if (is_on_gpu() && i == 42)
+                   {
+                     return true;
+                   }
+                   return false;
+                 });
+
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
     REQUIRE(result == true);
   }
 
-  TEST_CASE(
-    "nvexec just/continues_on supports move-only types",
-    "[cuda][stream][adaptors][continues_on]") {
-    nvexec::stream_context stream_ctx{};
+  TEST_CASE("nvexec just/continues_on supports move-only types",
+            "[cuda][stream][adaptors][continues_on]")
+  {
+    nvexec::stream_context   stream_ctx{};
     nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::just(move_only_t{42}) | ex::continues_on(gpu) //
-             | ex::then(
-                 [=](move_only_t&& val) noexcept { return is_on_gpu() && val.contains(42); });
+    auto snd = ex::just(move_only_t{42}) | ex::continues_on(gpu)  //
+             | ex::then([=](move_only_t&& val) noexcept
+                        { return is_on_gpu() && val.contains(42); });
 
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
     REQUIRE(result == true);
   }
 
-  TEST_CASE(
-    "nvexec continues_on supports move-only types",
-    "[cuda][stream][adaptors][continues_on]") {
+  TEST_CASE("nvexec continues_on supports move-only types",
+            "[cuda][stream][adaptors][continues_on]")
+  {
     nvexec::stream_context stream_ctx{};
 
     exec::single_thread_context cpu_ctx{};
-    auto cpu = cpu_ctx.get_scheduler();
-    nvexec::stream_scheduler gpu = stream_ctx.get_scheduler();
+    auto                        cpu = cpu_ctx.get_scheduler();
+    nvexec::stream_scheduler    gpu = stream_ctx.get_scheduler();
 
-    auto snd = ex::schedule(gpu)                        //
-             | ex::then([] { return move_only_t{42}; }) //
-             | ex::continues_on(cpu)                    //
+    auto snd = ex::schedule(gpu)                         //
+             | ex::then([] { return move_only_t{42}; })  //
+             | ex::continues_on(cpu)                     //
              | ex::then([=](move_only_t val) noexcept { return !is_on_gpu() && val.contains(42); });
 
-    const auto [result] = STDEXEC::sync_wait(std::move(snd)).value();
+    auto const [result] = STDEXEC::sync_wait(std::move(snd)).value();
     REQUIRE(result == true);
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/transfer_when_all.cpp b/test/nvexec/transfer_when_all.cpp
index 4fbe027c7..c883fe6b4 100644
--- a/test/nvexec/transfer_when_all.cpp
+++ b/test/nvexec/transfer_when_all.cpp
@@ -25,100 +25,105 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE(
-    "nvexec transfer_when_all returns a sender",
-    "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all returns a sender",
+            "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
+    auto                   gpu = stream_ctx.get_scheduler();
+    auto                   snd = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all with environment returns a sender",
-    "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all with environment returns a sender",
+            "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
+    auto                   gpu = stream_ctx.get_scheduler();
+    auto                   snd = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all with no senders",
-    "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all with no senders",
+            "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd = ex::transfer_when_all(gpu);
+    auto                   gpu = stream_ctx.get_scheduler();
+    auto                   snd = ex::transfer_when_all(gpu);
     wait_for_value(std::move(snd));
   }
 
-  TEST_CASE("nvexec transfer_when_all one sender", "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all one sender", "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd = ex::transfer_when_all(gpu, ex::just(3.1415)); // NOLINT(modernize-use-std-numbers)
-    wait_for_value(std::move(snd), 3.1415);                  // NOLINT(modernize-use-std-numbers)
+    auto                   gpu = stream_ctx.get_scheduler();
+    auto snd = ex::transfer_when_all(gpu, ex::just(3.1415));  // NOLINT(modernize-use-std-numbers)
+    wait_for_value(std::move(snd), 3.1415);                   // NOLINT(modernize-use-std-numbers)
   }
 
-  TEST_CASE("nvexec transfer_when_all two senders", "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all two senders", "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd1 = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
-    auto snd2 = std::move(snd1) | ex::then([](int x, double y) { return x + y; });
-    wait_for_value(std::move(snd2), 3.1415); // NOLINT(modernize-use-std-numbers)
+    auto                   gpu  = stream_ctx.get_scheduler();
+    auto                   snd1 = ex::transfer_when_all(gpu, ex::just(3), ex::just(0.1415));
+    auto                   snd2 = std::move(snd1) | ex::then([](int x, double y) { return x + y; });
+    wait_for_value(std::move(snd2), 3.1415);  // NOLINT(modernize-use-std-numbers)
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all two senders on same scheduler",
-    "[cuda][stream][adaptors][transfer_when_all]") {
+  TEST_CASE("nvexec transfer_when_all two senders on same scheduler",
+            "[cuda][stream][adaptors][transfer_when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
-    auto snd1 = ex::transfer_when_all(
-      gpu, ex::just(3) | ex::continues_on(gpu), ex::just(0.1415) | ex::continues_on(gpu));
-    auto snd2 = std::move(snd1) | ex::then([](int x, double y) { return x + y; });
-    wait_for_value(std::move(snd2), 3.1415); // NOLINT(modernize-use-std-numbers)
+    auto                   gpu  = stream_ctx.get_scheduler();
+    auto                   snd1 = ex::transfer_when_all(gpu,
+                                      ex::just(3) | ex::continues_on(gpu),
+                                      ex::just(0.1415) | ex::continues_on(gpu));
+    auto                   snd2 = std::move(snd1) | ex::then([](int x, double y) { return x + y; });
+    wait_for_value(std::move(snd2), 3.1415);  // NOLINT(modernize-use-std-numbers)
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all_with_variant returns a sender",
-    "[cuda][stream][adaptors][transfer_when_all_with_variant]") {
+  TEST_CASE("nvexec transfer_when_all_with_variant returns a sender",
+            "[cuda][stream][adaptors][transfer_when_all_with_variant]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
+    auto                   gpu = stream_ctx.get_scheduler();
     auto snd = ex::transfer_when_all_with_variant(gpu, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all_with_variant with environment returns a sender",
-    "[cuda][stream][adaptors][transfer_when_all_with_variant]") {
+  TEST_CASE("nvexec transfer_when_all_with_variant with environment returns a sender",
+            "[cuda][stream][adaptors][transfer_when_all_with_variant]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
+    auto                   gpu = stream_ctx.get_scheduler();
     auto snd = ex::transfer_when_all_with_variant(gpu, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all_with_variant two senders",
-    "[cuda][stream][adaptors][transfer_when_all_with_variant]") {
+  TEST_CASE("nvexec transfer_when_all_with_variant two senders",
+            "[cuda][stream][adaptors][transfer_when_all_with_variant]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
+    auto                   gpu = stream_ctx.get_scheduler();
     auto snd1 = ex::transfer_when_all_with_variant(gpu, ex::just(3), ex::just(0.1415));
     auto snd2 = std::move(snd1) | ex::then([](auto&&, auto&&) { return 42; });
     wait_for_value(std::move(snd2), 42);
   }
 
-  TEST_CASE(
-    "nvexec transfer_when_all_with_variant basic example",
-    "[cuda][stream][adaptors][transfer_when_all_with_variant]") {
+  TEST_CASE("nvexec transfer_when_all_with_variant basic example",
+            "[cuda][stream][adaptors][transfer_when_all_with_variant]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto gpu = stream_ctx.get_scheduler();
+    auto                   gpu = stream_ctx.get_scheduler();
     ex::sender auto snd = ex::transfer_when_all_with_variant(gpu, ex::just(2), ex::just(3.14));
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int>>{2}, std::variant<std::tuple<double>>{3.14});
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int>>{2},
+                   std::variant<std::tuple<double>>{3.14});
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/upon_error.cpp b/test/nvexec/upon_error.cpp
index cc3aea656..0ac323bbd 100644
--- a/test/nvexec/upon_error.cpp
+++ b/test/nvexec/upon_error.cpp
@@ -8,74 +8,90 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec upon_error returns a sender", "[cuda][stream][adaptors][upon_error]") {
+  TEST_CASE("nvexec upon_error returns a sender", "[cuda][stream][adaptors][upon_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::upon_error([](int) { });
+             | ex::upon_error([](int) {});
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec upon_error executes on GPU", "[cuda][stream][adaptors][upon_error]") {
+  TEST_CASE("nvexec upon_error executes on GPU", "[cuda][stream][adaptors][upon_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::upon_error([=](int err) {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set();
-                 }
-               });
+             | ex::upon_error(
+                 [=](int err)
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set();
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec upon_error can preceed a sender without values",
-    "[cuda][stream][adaptors][upon_error]") {
+  TEST_CASE("nvexec upon_error can preceed a sender without values",
+            "[cuda][stream][adaptors][upon_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
+    auto               flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::upon_error([=](int err) {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set(0);
-                 }
-               })
-             | a_sender([=]() noexcept {
-                 if (is_on_gpu()) {
-                   flags.set(1);
-                 }
-               });
+             | ex::upon_error(
+                 [=](int err)
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set(0);
+                   }
+                 })
+             | a_sender(
+                 [=]() noexcept
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set(1);
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE(
-    "nvexec upon_error can succeed a sender without values",
-    "[cuda][stream][adaptors][upon_error]") {
+  TEST_CASE("nvexec upon_error can succeed a sender without values",
+            "[cuda][stream][adaptors][upon_error]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just_error(42) | ex::continues_on(stream_ctx.get_scheduler())
-             | a_sender([=]() noexcept { }) | ex::upon_error([=](int err) noexcept {
-                 if (is_on_gpu() && err == 42) {
-                   flags.set();
-                 }
-               });
+             | a_sender([=]() noexcept {})
+             | ex::upon_error(
+                 [=](int err) noexcept
+                 {
+                   if (is_on_gpu() && err == 42)
+                   {
+                     flags.set();
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/upon_stopped.cpp b/test/nvexec/upon_stopped.cpp
index 1d23f9f70..778434183 100644
--- a/test/nvexec/upon_stopped.cpp
+++ b/test/nvexec/upon_stopped.cpp
@@ -8,9 +8,11 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec upon_stopped returns a sender", "[cuda][stream][adaptors][upon_stopped]") {
+  TEST_CASE("nvexec upon_stopped returns a sender", "[cuda][stream][adaptors][upon_stopped]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::just_stopped() | ex::continues_on(stream_ctx.get_scheduler())
@@ -19,20 +21,24 @@ namespace {
     (void) snd;
   }
 
-  TEST_CASE("nvexec upon_stopped executes on GPU", "[cuda][stream][adaptors][upon_stopped]") {
+  TEST_CASE("nvexec upon_stopped executes on GPU", "[cuda][stream][adaptors][upon_stopped]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t flags_storage{};
-    auto flags = flags_storage.get();
+    auto            flags = flags_storage.get();
 
     auto snd = ex::just_stopped() | ex::continues_on(stream_ctx.get_scheduler())
-             | ex::upon_stopped([=] {
-                 if (is_on_gpu()) {
-                   flags.set();
-                 }
-               });
+             | ex::upon_stopped(
+                 [=]
+                 {
+                   if (is_on_gpu())
+                   {
+                     flags.set();
+                   }
+                 });
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
-} // namespace
+}  // namespace
diff --git a/test/nvexec/variant.cpp b/test/nvexec/variant.cpp
index 8d9865e7b..425d5dd9c 100644
--- a/test/nvexec/variant.cpp
+++ b/test/nvexec/variant.cpp
@@ -29,9 +29,11 @@ STDEXEC_PRAGMA_IGNORE_EDG(cuda_compile)
 using nvexec::variant_t;
 using nvexec::visit;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec variant max size is correct", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant max size is correct", "[cuda][stream][containers][variant]")
+  {
     STATIC_REQUIRE(variant_t<double>::max_size == sizeof(double));
     STATIC_REQUIRE(variant_t<int, double>::max_size == sizeof(double));
     STATIC_REQUIRE(variant_t<char, int, double>::max_size == sizeof(double));
@@ -39,7 +41,8 @@ namespace {
     STATIC_REQUIRE(variant_t<char>::max_size == sizeof(char));
   }
 
-  TEST_CASE("nvexec variant max alignment is correct", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant max alignment is correct", "[cuda][stream][containers][variant]")
+  {
     STATIC_REQUIRE(variant_t<double>::max_size == std::alignment_of_v<double>);
     STATIC_REQUIRE(variant_t<int, double>::max_size == std::alignment_of_v<double>);
     STATIC_REQUIRE(variant_t<char, int, double>::max_size == std::alignment_of_v<double>);
@@ -47,13 +50,15 @@ namespace {
     STATIC_REQUIRE(variant_t<char>::max_size == std::alignment_of_v<char>);
   }
 
-  TEST_CASE("nvexec variant size is correct", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant size is correct", "[cuda][stream][containers][variant]")
+  {
     STATIC_REQUIRE(variant_t<double>::size == 1);
     STATIC_REQUIRE(variant_t<int, double>::size == 2);
     STATIC_REQUIRE(variant_t<char, int, double>::size == 3);
   }
 
-  TEST_CASE("nvexec variant emplaces alternative from CPU", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant emplaces alternative from CPU", "[cuda][stream][containers][variant]")
+  {
     variant_t<int, double> v;
     REQUIRE(v.index_ == 0);
 
@@ -65,14 +70,16 @@ namespace {
   }
 
   template <class T, class V>
-  __global__ void _variant_emplace_kernel(V* v, T alt) {
+  __global__ void _variant_emplace_kernel(V* v, T alt)
+  {
     v->template emplace<T>(alt);
   }
 
-  TEST_CASE("nvexec variant emplaces alternative from GPU", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant emplaces alternative from GPU", "[cuda][stream][containers][variant]")
+  {
     using variant_t = variant_t<int, double>;
     thrust::universal_vector<variant_t> variant_storage(1);
-    variant_t* v = thrust::raw_pointer_cast(variant_storage.data());
+    variant_t*                          v = thrust::raw_pointer_cast(variant_storage.data());
 
     REQUIRE(v->index_ == 0);
 
@@ -87,15 +94,18 @@ namespace {
     visit([](auto alt) { REQUIRE(alt == 42); }, *v);
   }
 
-  TEST_CASE("nvexec variant works with cuda tuple", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant works with cuda tuple", "[cuda][stream][containers][variant]")
+  {
     variant_t<cuda::std::tuple<int, double>, cuda::std::tuple<char, int>> v;
     REQUIRE(v.index_ == 0);
 
     v.emplace<cuda::std::tuple<int, double>>(42, 4.2);
     visit(
-      [](auto& tuple) {
+      [](auto& tuple)
+      {
         cuda::std::apply(
-          [](auto i, auto d) {
+          [](auto i, auto d)
+          {
             REQUIRE(i == 42);
             REQUIRE(d == 4.2);
           },
@@ -105,9 +115,11 @@ namespace {
 
     v.emplace<cuda::std::tuple<char, int>>('f', 4);
     visit(
-      [](auto& tuple) {
+      [](auto& tuple)
+      {
         cuda::std::apply(
-          [](auto c, auto i) {
+          [](auto c, auto i)
+          {
             REQUIRE(c == 'f');
             REQUIRE(i == 4);
           },
@@ -116,14 +128,17 @@ namespace {
       v);
   }
 
-  TEST_CASE("nvexec variant internal index bypass works", "[cuda][stream][containers][variant]") {
+  TEST_CASE("nvexec variant internal index bypass works", "[cuda][stream][containers][variant]")
+  {
     variant_t<cuda::std::tuple<int, double>, cuda::std::tuple<char, int>> v;
 
     v.emplace<cuda::std::tuple<int, double>>(42, 4.2);
     visit(
-      [](auto& tuple) {
+      [](auto& tuple)
+      {
         cuda::std::apply(
-          [](auto i, auto d) {
+          [](auto i, auto d)
+          {
             REQUIRE(i == 42);
             REQUIRE(d == 4.2);
           },
@@ -134,9 +149,11 @@ namespace {
 
     v.emplace<cuda::std::tuple<char, int>>('f', 4);
     visit(
-      [](auto& tuple) {
+      [](auto& tuple)
+      {
         cuda::std::apply(
-          [](auto c, auto i) {
+          [](auto c, auto i)
+          {
             REQUIRE(c == 'f');
             REQUIRE(i == 4);
           },
@@ -145,6 +162,6 @@ namespace {
       v,
       1);
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/nvexec/when_all.cpp b/test/nvexec/when_all.cpp
index b452fd37f..8149e6f95 100644
--- a/test/nvexec/when_all.cpp
+++ b/test/nvexec/when_all.cpp
@@ -9,51 +9,64 @@ namespace ex = STDEXEC;
 
 using nvexec::is_on_gpu;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("nvexec when_all returns a sender", "[cuda][stream][adaptors][when_all]") {
+  TEST_CASE("nvexec when_all returns a sender", "[cuda][stream][adaptors][when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto snd = ex::when_all(
-      ex::schedule(stream_ctx.get_scheduler()), ex::schedule(stream_ctx.get_scheduler()));
+    auto                   snd = ex::when_all(ex::schedule(stream_ctx.get_scheduler()),
+                            ex::schedule(stream_ctx.get_scheduler()));
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("nvexec when_all works", "[cuda][stream][adaptors][when_all]") {
+  TEST_CASE("nvexec when_all works", "[cuda][stream][adaptors][when_all]")
+  {
     nvexec::stream_context stream_ctx{};
 
     flags_storage_t<2> flags_storage{};
-    auto flags = flags_storage.get();
-
-    auto snd = ex::when_all(
-      ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] {
-        if (is_on_gpu()) {
-          flags.set(0);
-        }
-      }),
-      ex::schedule(stream_ctx.get_scheduler()) | ex::then([=] {
-        if (is_on_gpu()) {
-          flags.set(1);
-        }
-      }));
+    auto               flags = flags_storage.get();
+
+    auto snd = ex::when_all(ex::schedule(stream_ctx.get_scheduler())
+                              | ex::then(
+                                [=]
+                                {
+                                  if (is_on_gpu())
+                                  {
+                                    flags.set(0);
+                                  }
+                                }),
+                            ex::schedule(stream_ctx.get_scheduler())
+                              | ex::then(
+                                [=]
+                                {
+                                  if (is_on_gpu())
+                                  {
+                                    flags.set(1);
+                                  }
+                                }));
     STDEXEC::sync_wait(std::move(snd));
 
     REQUIRE(flags_storage.all_set_once());
   }
 
-  TEST_CASE("nvexec when_all returns values", "[cuda][stream][adaptors][when_all]") {
+  TEST_CASE("nvexec when_all returns values", "[cuda][stream][adaptors][when_all]")
+  {
     nvexec::stream_context stream_ctx{};
 
-    auto snd = ex::when_all(
-      ex::schedule(stream_ctx.get_scheduler()) | ex::then([] { return is_on_gpu() * 24; }),
-      ex::schedule(stream_ctx.get_scheduler()) | ex::then([] { return is_on_gpu() * 42; }));
+    auto snd      = ex::when_all(ex::schedule(stream_ctx.get_scheduler())
+                              | ex::then([] { return is_on_gpu() * 24; }),
+                            ex::schedule(stream_ctx.get_scheduler())
+                              | ex::then([] { return is_on_gpu() * 42; }));
     auto [v1, v2] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(v1 == 24);
     REQUIRE(v2 == 42);
   }
 
-  TEST_CASE("nvexec when_all with many senders", "[cuda][stream][adaptors][when_all]") {
+  TEST_CASE("nvexec when_all with many senders", "[cuda][stream][adaptors][when_all]")
+  {
     nvexec::stream_context stream_ctx{};
 
     auto snd = ex::when_all(
@@ -71,16 +84,16 @@ namespace {
     REQUIRE(v5 == 5);
   }
 
-  TEST_CASE("nvexec when_all works with unknown senders", "[cuda][stream][adaptors][when_all]") {
+  TEST_CASE("nvexec when_all works with unknown senders", "[cuda][stream][adaptors][when_all]")
+  {
     nvexec::stream_context stream_ctx{};
-    auto sch = stream_ctx.get_scheduler();
+    auto                   sch = stream_ctx.get_scheduler();
 
-    auto snd = ex::when_all(
-      ex::schedule(sch) | ex::then([]() -> int { return is_on_gpu() * 24; }),
-      ex::schedule(sch) | a_sender([]() -> int { return is_on_gpu() * 42; }));
+    auto snd = ex::when_all(ex::schedule(sch) | ex::then([]() -> int { return is_on_gpu() * 24; }),
+                            ex::schedule(sch) | a_sender([]() -> int { return is_on_gpu() * 42; }));
     auto [v1, v2] = STDEXEC::sync_wait(std::move(snd)).value();
 
     REQUIRE(v1 == 24);
     REQUIRE(v2 == 42);
   }
-} // namespace
+}  // namespace
diff --git a/test/rrd/async_scope.cpp b/test/rrd/async_scope.cpp
index e471a5769..99f650f15 100644
--- a/test/rrd/async_scope.cpp
+++ b/test/rrd/async_scope.cpp
@@ -15,16 +15,18 @@ using rl::mutex;
 namespace ex = STDEXEC;
 using exec::async_scope;
 
-struct drop_async_scope_future : rl::test_suite<drop_async_scope_future, 1> {
+struct drop_async_scope_future : rl::test_suite<drop_async_scope_future, 1>
+{
   static size_t const dynamic_thread_count = 1;
 
-  void thread(unsigned) {
+  void thread(unsigned)
+  {
     exec::single_thread_context ctx;
-    ex::scheduler auto sch = ctx.get_scheduler();
+    ex::scheduler auto          sch = ctx.get_scheduler();
 
     exec::async_scope scope;
-    std::atomic_bool produced{false};
-    ex::sender auto begin = ex::schedule(sch);
+    std::atomic_bool  produced{false};
+    ex::sender auto   begin = ex::schedule(sch);
     {
       ex::sender auto ftr = scope.spawn_future(begin | ex::then([&]() { produced.store(true); }));
       (void) ftr;
@@ -33,49 +35,58 @@ struct drop_async_scope_future : rl::test_suite<drop_async_scope_future, 1> {
   }
 };
 
-struct attach_async_scope_future : rl::test_suite<attach_async_scope_future, 1> {
+struct attach_async_scope_future : rl::test_suite<attach_async_scope_future, 1>
+{
   static size_t const dynamic_thread_count = 1;
 
-  void thread(unsigned) {
+  void thread(unsigned)
+  {
     exec::single_thread_context ctx;
-    ex::scheduler auto sch = ctx.get_scheduler();
+    ex::scheduler auto          sch = ctx.get_scheduler();
 
     exec::async_scope scope;
-    std::atomic_bool produced{false};
-    ex::sender auto begin = ex::schedule(sch);
-    ex::sender auto ftr = scope.spawn_future(begin | ex::then([&]() { produced.store(true); }));
-    ex::sender auto ftr_then = std::move(ftr) | ex::then([&] { RL_ASSERT(produced.load()); });
+    std::atomic_bool  produced{false};
+    ex::sender auto   begin = ex::schedule(sch);
+    ex::sender auto   ftr   = scope.spawn_future(begin | ex::then([&]() { produced.store(true); }));
+    ex::sender auto   ftr_then = std::move(ftr) | ex::then([&] { RL_ASSERT(produced.load()); });
     ex::sync_wait(ex::when_all(scope.on_empty(), std::move(ftr_then)));
   }
 };
 
-struct async_scope_future_set_result : rl::test_suite<async_scope_future_set_result, 1> {
+struct async_scope_future_set_result : rl::test_suite<async_scope_future_set_result, 1>
+{
   static size_t const dynamic_thread_count = 1;
 
-  void thread(unsigned) {
-    struct throwing_copy {
+  void thread(unsigned)
+  {
+    struct throwing_copy
+    {
       throwing_copy() = default;
 
-      throwing_copy(const throwing_copy&) {
+      throwing_copy(throwing_copy const &)
+      {
         throw std::logic_error("");
       }
     };
 
     exec::single_thread_context ctx;
-    ex::scheduler auto sch = ctx.get_scheduler();
+    ex::scheduler auto          sch = ctx.get_scheduler();
 
     exec::async_scope scope;
-    ex::sender auto begin = ex::schedule(sch);
-    ex::sender auto ftr = scope.spawn_future(begin | ex::then([] { return throwing_copy(); }));
-    bool threw = false;
-    STDEXEC_TRY {
+    ex::sender auto   begin = ex::schedule(sch);
+    ex::sender auto   ftr   = scope.spawn_future(begin | ex::then([] { return throwing_copy(); }));
+    bool              threw = false;
+    STDEXEC_TRY
+    {
       ex::sync_wait(std::move(ftr));
       RL_ASSERT(false);
     }
-    STDEXEC_CATCH(const std::logic_error&) {
+    STDEXEC_CATCH(std::logic_error const &)
+    {
       threw = true;
     }
-    STDEXEC_CATCH_ALL {
+    STDEXEC_CATCH_ALL
+    {
       RL_ASSERT(false);
     }
     RL_ASSERT(threw);
@@ -84,22 +95,27 @@ struct async_scope_future_set_result : rl::test_suite<async_scope_future_set_res
 };
 
 template <int test_case>
-struct async_scope_request_stop : rl::test_suite<async_scope_request_stop<test_case>, 1> {
+struct async_scope_request_stop : rl::test_suite<async_scope_request_stop<test_case>, 1>
+{
   static size_t const dynamic_thread_count = 1;
 
-  void thread(unsigned) {
+  void thread(unsigned)
+  {
     exec::single_thread_context ctx;
-    ex::scheduler auto sch = ctx.get_scheduler();
+    ex::scheduler auto          sch = ctx.get_scheduler();
 
-    if constexpr (test_case == 0) {
+    if constexpr (test_case == 0)
+    {
       exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
-      ex::sender auto ftr = scope.spawn_future(scope.spawn_future(begin));
+      ex::sender auto   begin = ex::schedule(sch);
+      ex::sender auto   ftr   = scope.spawn_future(scope.spawn_future(begin));
       scope.request_stop();
       ex::sync_wait(ex::when_all(scope.on_empty(), std::move(ftr)));
-    } else {
+    }
+    else
+    {
       exec::async_scope scope;
-      ex::sender auto begin = ex::schedule(sch);
+      ex::sender auto   begin = ex::schedule(sch);
       {
         // Drop the future on the floor
         ex::sender auto ftr = scope.spawn_future(scope.spawn_future(begin));
@@ -110,9 +126,10 @@ struct async_scope_request_stop : rl::test_suite<async_scope_request_stop<test_c
   }
 };
 
-auto main() -> int {
+auto main() -> int
+{
   rl::test_params p;
-  p.iteration_count = 100000;
+  p.iteration_count       = 100000;
   p.execution_depth_limit = 10000;
   rl::simulate<drop_async_scope_future>(p);
   rl::simulate<attach_async_scope_future>(p);
diff --git a/test/rrd/split.cpp b/test/rrd/split.cpp
index e9499a14b..549e50c5b 100644
--- a/test/rrd/split.cpp
+++ b/test/rrd/split.cpp
@@ -11,10 +11,12 @@ using rl::mutex;
 
 namespace ex = STDEXEC;
 
-struct split_bug : rl::test_suite<split_bug, 1> {
+struct split_bug : rl::test_suite<split_bug, 1>
+{
   static size_t const dynamic_thread_count = 2;
 
-  void thread(unsigned) {
+  void thread(unsigned)
+  {
     exec::static_thread_pool pool{1};
     auto split = ex::schedule(pool.get_scheduler()) | ex::then([] { return 42; }) | exec::split();
 
@@ -23,9 +25,10 @@ struct split_bug : rl::test_suite<split_bug, 1> {
   }
 };
 
-auto main() -> int {
+auto main() -> int
+{
   rl::test_params p;
-  p.iteration_count = 50000;
+  p.iteration_count       = 50000;
   p.execution_depth_limit = 10000;
   rl::simulate<split_bug>(p);
   return 0;
diff --git a/test/rrd/sync_wait.cpp b/test/rrd/sync_wait.cpp
index 1d78d9528..67d30a10c 100644
--- a/test/rrd/sync_wait.cpp
+++ b/test/rrd/sync_wait.cpp
@@ -22,10 +22,12 @@
 
 namespace ex = STDEXEC;
 
-struct sync_wait_bg_thread : rl::test_suite<sync_wait_bg_thread, 1> {
+struct sync_wait_bg_thread : rl::test_suite<sync_wait_bg_thread, 1>
+{
   static size_t const dynamic_thread_count = 1;
 
-  void thread(unsigned) {
+  void thread(unsigned)
+  {
     exec::static_thread_pool pool{1};
     auto sender = ex::schedule(pool.get_scheduler()) | ex::then([] { return 42; });
 
@@ -34,11 +36,12 @@ struct sync_wait_bg_thread : rl::test_suite<sync_wait_bg_thread, 1> {
   }
 };
 
-auto main() -> int {
+auto main() -> int
+{
   rl::test_params p;
-  p.iteration_count = 50000;
+  p.iteration_count       = 50000;
   p.execution_depth_limit = 10000;
-  p.search_type = rl::random_scheduler_type;
+  p.search_type           = rl::random_scheduler_type;
   rl::simulate<sync_wait_bg_thread>(p);
   return 0;
 }
diff --git a/test/stdexec/algos/adaptors/test_associate.cpp b/test/stdexec/algos/adaptors/test_associate.cpp
index b9312f57b..2839accdd 100644
--- a/test/stdexec/algos/adaptors/test_associate.cpp
+++ b/test/stdexec/algos/adaptors/test_associate.cpp
@@ -25,16 +25,19 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("associate returns a sender", "[adaptors][associate]") {
+namespace
+{
+  TEST_CASE("associate returns a sender", "[adaptors][associate]")
+  {
     using snd_t = decltype(ex::associate(ex::just(), null_token{}));
 
     STATIC_REQUIRE(ex::sender<snd_t>);
-    STATIC_REQUIRE(ex::sender<snd_t&>);
-    STATIC_REQUIRE(ex::sender<const snd_t&>);
+    STATIC_REQUIRE(ex::sender<snd_t &>);
+    STATIC_REQUIRE(ex::sender<snd_t const &>);
   }
 
-  TEST_CASE("associate is appropriately noexcept", "[adaptors][associate]") {
+  TEST_CASE("associate is appropriately noexcept", "[adaptors][associate]")
+  {
     // double-check our dependencies
     STATIC_REQUIRE(noexcept(ex::just()));
     STATIC_REQUIRE(noexcept(null_token{}));
@@ -50,20 +53,22 @@ namespace {
 
     // conversely, trafficking in senders with potentially-throwing copy
     // constructors should lead to the whole expression becoming potentially-throwing
-    const auto justString = ex::just(std::string{"Copying strings is potentially-throwing"});
+    auto const justString = ex::just(std::string{"Copying strings is potentially-throwing"});
     STATIC_REQUIRE(!noexcept(ex::associate(justString, null_token{})));
     STATIC_REQUIRE(!noexcept(justString | ex::associate(null_token{})));
     (void) justString;
   }
 
   template <class Sender, class... CompSig>
-  constexpr bool expected_completion_signatures() {
+  constexpr bool expected_completion_signatures()
+  {
     using expected_sigs = ex::completion_signatures<CompSig...>;
-    using actual_sigs = ex::completion_signatures_of_t<Sender>;
+    using actual_sigs   = ex::completion_signatures_of_t<Sender>;
     return expected_sigs{} == actual_sigs{};
   }
 
-  TEST_CASE("associate has appropriate completion signatures", "[adaptors][associate]") {
+  TEST_CASE("associate has appropriate completion signatures", "[adaptors][associate]")
+  {
     {
       using snd_t = decltype(ex::associate(ex::just(), null_token{}));
 
@@ -71,10 +76,10 @@ namespace {
         expected_completion_signatures<snd_t, ex::set_value_t(), ex::set_stopped_t()>());
 
       STATIC_REQUIRE(
-        expected_completion_signatures<snd_t&, ex::set_value_t(), ex::set_stopped_t()>());
+        expected_completion_signatures<snd_t &, ex::set_value_t(), ex::set_stopped_t()>());
 
       STATIC_REQUIRE(
-        expected_completion_signatures<const snd_t&, ex::set_value_t(), ex::set_stopped_t()>());
+        expected_completion_signatures<snd_t const &, ex::set_value_t(), ex::set_stopped_t()>());
     }
 
     {
@@ -83,15 +88,13 @@ namespace {
       STATIC_REQUIRE(
         expected_completion_signatures<snd_t, ex::set_value_t(std::string), ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(
-        expected_completion_signatures<snd_t&, ex::set_value_t(std::string), ex::set_stopped_t()>());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t &,
+                                                    ex::set_value_t(std::string),
+                                                    ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(
-        expected_completion_signatures<
-          const snd_t&,
-          ex::set_value_t(std::string),
-          ex::set_stopped_t()
-        >());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t const &,
+                                                    ex::set_value_t(std::string),
+                                                    ex::set_stopped_t()>());
     }
 
     {
@@ -99,9 +102,9 @@ namespace {
 
       STATIC_REQUIRE(expected_completion_signatures<snd_t, ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(expected_completion_signatures<snd_t&, ex::set_stopped_t()>());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t &, ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(expected_completion_signatures<const snd_t&, ex::set_stopped_t()>());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t const &, ex::set_stopped_t()>());
     }
 
     {
@@ -111,41 +114,34 @@ namespace {
         expected_completion_signatures<snd_t, ex::set_error_t(int), ex::set_stopped_t()>());
 
       STATIC_REQUIRE(
-        expected_completion_signatures<snd_t&, ex::set_error_t(int), ex::set_stopped_t()>());
+        expected_completion_signatures<snd_t &, ex::set_error_t(int), ex::set_stopped_t()>());
 
       STATIC_REQUIRE(
-        expected_completion_signatures<const snd_t&, ex::set_error_t(int), ex::set_stopped_t()>());
+        expected_completion_signatures<snd_t const &, ex::set_error_t(int), ex::set_stopped_t()>());
     }
 
     {
-      int i = 42;
+      int i       = 42;
       using snd_t = decltype(ex::associate(ex::just(std::ref(i)), null_token{}));
 
-      STATIC_REQUIRE(
-        expected_completion_signatures<
-          snd_t,
-          ex::set_value_t(std::reference_wrapper<int>),
-          ex::set_stopped_t()
-        >());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t,
+                                                    ex::set_value_t(std::reference_wrapper<int>),
+                                                    ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(
-        expected_completion_signatures<
-          snd_t&,
-          ex::set_value_t(std::reference_wrapper<int>),
-          ex::set_stopped_t()
-        >());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t &,
+                                                    ex::set_value_t(std::reference_wrapper<int>),
+                                                    ex::set_stopped_t()>());
 
-      STATIC_REQUIRE(
-        expected_completion_signatures<
-          const snd_t&,
-          ex::set_value_t(std::reference_wrapper<int>),
-          ex::set_stopped_t()
-        >());
+      STATIC_REQUIRE(expected_completion_signatures<snd_t const &,
+                                                    ex::set_value_t(std::reference_wrapper<int>),
+                                                    ex::set_stopped_t()>());
     }
   }
 
-  TEST_CASE("associate is the identity with null_token", "[adaptors][associate]") {
-    auto checkForIdentity = []<class... V>(ex::sender auto snd, V... values) {
+  TEST_CASE("associate is the identity with null_token", "[adaptors][associate]")
+  {
+    auto checkForIdentity = []<class... V>(ex::sender auto snd, V... values)
+    {
       // wait_for_values wants prvalue expected values
       wait_for_value(snd, V(values)...);
       wait_for_value(std::as_const(snd), V(values)...);
@@ -166,85 +162,98 @@ namespace {
     checkForIdentity(ex::just(std::ref(i)) | ex::associate(null_token{}), std::ref(i));
 
     // passing set_value(int) through to another adaptor
-    checkForIdentity(
-      ex::just(42) | ex::associate(null_token{}) | ex::then([](int i) noexcept { return i; }), 42);
+    checkForIdentity(ex::just(42) | ex::associate(null_token{})
+                       | ex::then([](int i) noexcept { return i; }),
+                     42);
 
     // passing set_error(int) through to another adaptor
-    checkForIdentity(
-      ex::just_error(42) | ex::associate(null_token{}) | ex::upon_error([](int i) { return i; }),
-      42);
+    checkForIdentity(ex::just_error(42) | ex::associate(null_token{})
+                       | ex::upon_error([](int i) { return i; }),
+                     42);
 
     // passing set_stopped() through to another adaptor
-    checkForIdentity(
-      ex::just_stopped() | ex::associate(null_token{})
-        | ex::upon_stopped([]() noexcept { return 42; }),
-      42);
+    checkForIdentity(ex::just_stopped() | ex::associate(null_token{})
+                       | ex::upon_stopped([]() noexcept { return 42; }),
+                     42);
   }
 
-  struct expired_token {
-    struct assoc {
-      constexpr operator bool() const noexcept {
+  struct expired_token
+  {
+    struct assoc
+    {
+      constexpr operator bool() const noexcept
+      {
         return false;
       }
 
-      constexpr assoc try_associate() const noexcept {
+      constexpr assoc try_associate() const noexcept
+      {
         return {};
       }
     };
 
     template <ex::sender Sender>
-    constexpr Sender&& wrap(Sender&& sndr) const noexcept {
+    constexpr Sender &&wrap(Sender &&sndr) const noexcept
+    {
       return std::forward<Sender>(sndr);
     }
 
-    constexpr assoc try_associate() const noexcept {
+    constexpr assoc try_associate() const noexcept
+    {
       return {};
     }
   };
 
-  TEST_CASE("associate is just_stopped with expired_token", "[adaptors][associate]") {
-    wait_for_value(
-      ex::just(true) | ex::associate(expired_token{})
-        | ex::upon_stopped([]() noexcept { return false; }),
-      false);
+  TEST_CASE("associate is just_stopped with expired_token", "[adaptors][associate]")
+  {
+    wait_for_value(ex::just(true) | ex::associate(expired_token{})
+                     | ex::upon_stopped([]() noexcept { return false; }),
+                   false);
   }
 
-  struct scope {
+  struct scope
+  {
     bool open{true};
 
-    struct assoc {
-      constexpr operator bool() const noexcept {
+    struct assoc
+    {
+      constexpr operator bool() const noexcept
+      {
         return !!scope_;
       }
 
-      constexpr assoc try_associate() const noexcept {
+      constexpr assoc try_associate() const noexcept
+      {
         return assoc{scope_ && scope_->open ? scope_ : nullptr};
       }
 
-      const scope* scope_;
+      scope const *scope_;
     };
 
-    struct token {
+    struct token
+    {
       template <ex::sender Sender>
-      constexpr Sender&& wrap(Sender&& sndr) const noexcept {
+      constexpr Sender &&wrap(Sender &&sndr) const noexcept
+      {
         return std::forward<Sender>(sndr);
       }
 
-      constexpr assoc try_associate() const noexcept {
+      constexpr assoc try_associate() const noexcept
+      {
         return assoc{scope_->open ? scope_ : nullptr};
       }
 
-      const scope* scope_;
+      scope const *scope_;
     };
 
-    constexpr token get_token() const noexcept {
+    constexpr token get_token() const noexcept
+    {
       return token{this};
     }
   };
 
-  TEST_CASE(
-    "copying an associate-sender re-queries for a new association",
-    "[adaptors][associate]") {
+  TEST_CASE("copying an associate-sender re-queries for a new association", "[adaptors][associate]")
+  {
     STATIC_REQUIRE(ex::scope_token<scope::token>);
     STATIC_REQUIRE(ex::scope_association<scope::assoc>);
 
@@ -265,11 +274,11 @@ namespace {
     wait_for_value(std::move(snd), 42);
   }
 
-  TEST_CASE(
-    "the sender argument is eagerly destroyed when try_associate fails",
-    "[adaptors][associate]") {
-    bool deleted = false;
-    using deleter_t = decltype([](bool* p) noexcept { *p = true; });
+  TEST_CASE("the sender argument is eagerly destroyed when try_associate fails",
+            "[adaptors][associate]")
+  {
+    bool deleted    = false;
+    using deleter_t = decltype([](bool *p) noexcept { *p = true; });
     std::unique_ptr<bool, deleter_t> ptr(&deleted);
 
     auto snd = ex::just(std::move(ptr)) | ex::associate(expired_token{});
@@ -284,4 +293,4 @@ namespace {
   // TODO: check the pass-through stop request behaviour
   // TODO: confirm timing of destruction of opstate relative to release of association
   // TODO: confirm that the TODO list is exhaustive
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_bulk.cpp b/test/stdexec/algos/adaptors/test_bulk.cpp
index 161d47df5..3b21654e0 100644
--- a/test/stdexec/algos/adaptors/test_bulk.cpp
+++ b/test/stdexec/algos/adaptors/test_bulk.cpp
@@ -28,158 +28,181 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
   template <class Shape, int N, int (&Counter)[N]>
-  void function(Shape i) {
+  void function(Shape i)
+  {
     Counter[i]++;
   }
 
   template <class Shape, int N, int (&Counter)[N]>
-  void function_range(Shape b, Shape e) {
-    while (b != e) {
+  void function_range(Shape b, Shape e)
+  {
+    while (b != e)
+    {
       Counter[b++]++;
     }
   }
 
   template <class Shape>
-  struct function_object_t {
+  struct function_object_t
+  {
     int* Counter;
 
-    void operator()(Shape i) {
+    void operator()(Shape i)
+    {
       Counter[i]++;
     }
   };
 
   template <class Shape>
-  struct function_object_range_t {
+  struct function_object_range_t
+  {
     int* Counter;
 
-    void operator()(Shape b, Shape e) {
-      while (b != e) {
+    void operator()(Shape b, Shape e)
+    {
+      while (b != e)
+      {
         Counter[b++]++;
       }
     }
   };
 
-  constexpr auto test_constexpr() noexcept {
-    struct receiver {
+  constexpr auto test_constexpr() noexcept
+  {
+    struct receiver
+    {
       using receiver_concept = ex::receiver_t;
-      constexpr void set_value(const int j) && noexcept {
+      constexpr void set_value(int const j) && noexcept
+      {
         i = j;
       }
-      void set_error(std::exception_ptr) && noexcept {
-      }
+      void set_error(std::exception_ptr) && noexcept {}
       int& i;
     };
-    int i = 0;
-    auto op = ex::connect(
-      ex::just(666)
-        | ex::bulk(
-          ex::par, 42, [](std::size_t item, int& val) noexcept { val += static_cast<int>(item); }),
-      receiver{i});
+    int  i  = 0;
+    auto op = ex::connect(ex::just(666)
+                            | ex::bulk(ex::par,
+                                       42,
+                                       [](std::size_t item, int& val) noexcept
+                                       { val += static_cast<int>(item); }),
+                          receiver{i});
     ex::start(op);
     return i;
   }
   static_assert(test_constexpr() == 666 + 42 * 41 / 2);
 
-  TEST_CASE("bulk returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk(ex::just(19), ex::par, 8, [](int, int) { });
+  TEST_CASE("bulk returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk(ex::just(19), ex::par, 8, [](int, int) {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("bulk_chunked returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk_chunked(ex::just(19), ex::par, 8, [](int, int, int) { });
+  TEST_CASE("bulk_chunked returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk_chunked(ex::just(19), ex::par, 8, [](int, int, int) {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("bulk_unchunked returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk_unchunked(ex::just(19), ex::par, 8, [](int, int) { });
+  TEST_CASE("bulk_unchunked returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk_unchunked(ex::just(19), ex::par, 8, [](int, int) {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("bulk with environment returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk(ex::just(19), ex::par, 8, [](int, int) { });
+  TEST_CASE("bulk with environment returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk(ex::just(19), ex::par, 8, [](int, int) {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("bulk_chunked with environment returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk_chunked(ex::just(19), ex::par, 8, [](int, int, int) { });
+  TEST_CASE("bulk_chunked with environment returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk_chunked(ex::just(19), ex::par, 8, [](int, int, int) {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("bulk_unchunked with environment returns a sender", "[adaptors][bulk]") {
-    auto snd = ex::bulk_unchunked(ex::just(19), ex::par, 8, [](int, int) { });
+  TEST_CASE("bulk_unchunked with environment returns a sender", "[adaptors][bulk]")
+  {
+    auto snd = ex::bulk_unchunked(ex::just(19), ex::par, 8, [](int, int) {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("bulk can be piped", "[adaptors][bulk]") {
-    ex::sender auto snd = ex::just() | ex::bulk(ex::par, 42, [](int) { });
+  TEST_CASE("bulk can be piped", "[adaptors][bulk]")
+  {
+    ex::sender auto snd = ex::just() | ex::bulk(ex::par, 42, [](int) {});
     (void) snd;
   }
 
-  TEST_CASE("bulk_chunked can be piped", "[adaptors][bulk]") {
-    ex::sender auto snd = ex::just() | ex::bulk_chunked(ex::par, 42, [](int, int) { });
+  TEST_CASE("bulk_chunked can be piped", "[adaptors][bulk]")
+  {
+    ex::sender auto snd = ex::just() | ex::bulk_chunked(ex::par, 42, [](int, int) {});
     (void) snd;
   }
 
-  TEST_CASE("bulk_unchunked can be piped", "[adaptors][bulk]") {
-    ex::sender auto snd = ex::just() | ex::bulk_unchunked(ex::par, 42, [](int) { });
+  TEST_CASE("bulk_unchunked can be piped", "[adaptors][bulk]")
+  {
+    ex::sender auto snd = ex::just() | ex::bulk_unchunked(ex::par, 42, [](int) {});
     (void) snd;
   }
 
-  TEST_CASE("bulk keeps values_type from input sender", "[adaptors][bulk]") {
+  TEST_CASE("bulk keeps values_type from input sender", "[adaptors][bulk]")
+  {
     constexpr int n = 42;
-    check_val_types<ex::__mset<pack<>>>(ex::just() | ex::bulk(ex::par, n, [](int) { }));
-    check_val_types<ex::__mset<pack<double>>>(
-      ex::just(4.2) | ex::bulk(ex::par, n, [](int, double) { }));
+    check_val_types<ex::__mset<pack<>>>(ex::just() | ex::bulk(ex::par, n, [](int) {}));
+    check_val_types<ex::__mset<pack<double>>>(ex::just(4.2)
+                                              | ex::bulk(ex::par, n, [](int, double) {}));
     check_val_types<ex::__mset<pack<double, std::string>>>(
-      ex::just(4.2, std::string{}) | ex::bulk(ex::par, n, [](int, double, std::string) { }));
+      ex::just(4.2, std::string{}) | ex::bulk(ex::par, n, [](int, double, std::string) {}));
   }
 
-  TEST_CASE("bulk_chunked keeps values_type from input sender", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked keeps values_type from input sender", "[adaptors][bulk]")
+  {
     constexpr int n = 42;
-    check_val_types<ex::__mset<pack<>>>(
-      ex::just() | ex::bulk_chunked(ex::par, n, [](int, int) { }));
+    check_val_types<ex::__mset<pack<>>>(ex::just() | ex::bulk_chunked(ex::par, n, [](int, int) {}));
     check_val_types<ex::__mset<pack<double>>>(
-      ex::just(4.2) | ex::bulk_chunked(ex::par, n, [](int, int, double) { }));
+      ex::just(4.2) | ex::bulk_chunked(ex::par, n, [](int, int, double) {}));
     check_val_types<ex::__mset<pack<double, std::string>>>(
       ex::just(4.2, std::string{})
-      | ex::bulk_chunked(ex::par, n, [](int, int, double, std::string) { }));
+      | ex::bulk_chunked(ex::par, n, [](int, int, double, std::string) {}));
   }
 
-  TEST_CASE("bulk_unchunked keeps values_type from input sender", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked keeps values_type from input sender", "[adaptors][bulk]")
+  {
     constexpr int n = 42;
-    check_val_types<ex::__mset<pack<>>>(ex::just() | ex::bulk_unchunked(ex::par, n, [](int) { }));
-    check_val_types<ex::__mset<pack<double>>>(
-      ex::just(4.2) | ex::bulk_unchunked(ex::par, n, [](int, double) { }));
+    check_val_types<ex::__mset<pack<>>>(ex::just() | ex::bulk_unchunked(ex::par, n, [](int) {}));
+    check_val_types<ex::__mset<pack<double>>>(ex::just(4.2)
+                                              | ex::bulk_unchunked(ex::par, n, [](int, double) {}));
     check_val_types<ex::__mset<pack<double, std::string>>>(
       ex::just(4.2, std::string{})
-      | ex::bulk_unchunked(ex::par, n, [](int, double, std::string) { }));
+      | ex::bulk_unchunked(ex::par, n, [](int, double, std::string) {}));
   }
 
-  TEST_CASE("bulk keeps error_types from input sender", "[adaptors][bulk]") {
+  TEST_CASE("bulk keeps error_types from input sender", "[adaptors][bulk]")
+  {
     [[maybe_unused]]
-    constexpr int n = 42;
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+    constexpr int        n = 42;
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
 #if !STDEXEC_MSVC()
     // MSVCBUG https://developercommunity.visualstudio.com/t/noexcept-expression-in-lambda-template-n/10718680
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1) | ex::bulk(ex::par, n, [](int) noexcept { }));
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::bulk(ex::par, n, [](int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just_error(n) | ex::bulk(ex::par, n, [](int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just() | ex::continues_on(sched3) | ex::bulk(ex::par, n, [](int) noexcept { }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::bulk(ex::par, n, [](int) noexcept {}));
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched2)
+                                                    | ex::bulk(ex::par, n, [](int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just_error(n) | ex::bulk(ex::par, n, [](int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just() | ex::continues_on(sched3)
+                                     | ex::bulk(ex::par, n, [](int) noexcept {}));
 #  if !STDEXEC_NO_STD_EXCEPTIONS()
     check_err_types<ex::__mset<std::exception_ptr, int>>(
       ex::just() | ex::continues_on(sched3)
@@ -188,23 +211,22 @@ namespace {
 #endif
   }
 
-  TEST_CASE("bulk_chunked keeps error_types from input sender", "[adaptors][bulk]") {
-    constexpr int n = 42;
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("bulk_chunked keeps error_types from input sender", "[adaptors][bulk]")
+  {
+    constexpr int        n = 42;
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1)
-      | ex::bulk_chunked(ex::par, n, [](int, int) noexcept { }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::bulk_chunked(ex::par, n, [](int, int) noexcept {}));
     check_err_types<ex::__mset<std::exception_ptr>>(
       ex::just() | ex::continues_on(sched2)
-      | ex::bulk_chunked(ex::par, n, [](int, int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just_error(n) | ex::bulk_chunked(ex::par, n, [](int, int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just() | ex::continues_on(sched3)
-      | ex::bulk_chunked(ex::par, n, [](int, int) noexcept { }));
+      | ex::bulk_chunked(ex::par, n, [](int, int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just_error(n)
+                                     | ex::bulk_chunked(ex::par, n, [](int, int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just() | ex::continues_on(sched3)
+                                     | ex::bulk_chunked(ex::par, n, [](int, int) noexcept {}));
 #if !STDEXEC_NO_STD_EXCEPTIONS()
     check_err_types<ex::__mset<std::exception_ptr, int>>(
       ex::just() | ex::continues_on(sched3)
@@ -212,20 +234,21 @@ namespace {
 #endif
   }
 
-  TEST_CASE("bulk_unchunked keeps error_types from input sender", "[adaptors][bulk]") {
-    constexpr int n = 42;
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("bulk_unchunked keeps error_types from input sender", "[adaptors][bulk]")
+  {
+    constexpr int        n = 42;
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1) | ex::bulk_unchunked(ex::par, n, [](int) noexcept { }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::bulk_unchunked(ex::par, n, [](int) noexcept {}));
     check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::bulk_unchunked(ex::par, n, [](int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just_error(n) | ex::bulk_unchunked(ex::par, n, [](int) noexcept { }));
-    check_err_types<ex::__mset<int>>(
-      ex::just() | ex::continues_on(sched3) | ex::bulk_unchunked(ex::par, n, [](int) noexcept { }));
+      ex::just() | ex::continues_on(sched2) | ex::bulk_unchunked(ex::par, n, [](int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just_error(n)
+                                     | ex::bulk_unchunked(ex::par, n, [](int) noexcept {}));
+    check_err_types<ex::__mset<int>>(ex::just() | ex::continues_on(sched3)
+                                     | ex::bulk_unchunked(ex::par, n, [](int) noexcept {}));
 #if !STDEXEC_NO_STD_EXCEPTIONS()
     check_err_types<ex::__mset<std::exception_ptr, int>>(
       ex::just() | ex::continues_on(sched3)
@@ -233,23 +256,26 @@ namespace {
 #endif
   }
 
-  TEST_CASE("bulk can be used with a function", "[adaptors][bulk]") {
+  TEST_CASE("bulk can be used with a function", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    static int counter1[n]{};
+    static int    counter1[n]{};
     std::fill_n(counter1, n, 0);
 
     ex::sender auto snd = ex::just() | ex::bulk(ex::par, n, function<int, n, counter1>);
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i: counter1) {
+    for (int i: counter1)
+    {
       CHECK(i == 1);
     }
   }
 
-  TEST_CASE("bulk_chunked can be used with a function", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked can be used with a function", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    static int counter2[n]{};
+    static int    counter2[n]{};
     std::fill_n(counter2, n, 0);
 
     ex::sender auto snd = ex::just()
@@ -257,114 +283,134 @@ namespace {
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter2[i] == 1);
     }
   }
 
-  TEST_CASE("bulk_unchunked can be used with a function", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked can be used with a function", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    static int counter3[n]{};
+    static int    counter3[n]{};
     std::fill_n(counter3, n, 0);
 
     ex::sender auto snd = ex::just() | ex::bulk_unchunked(ex::par, n, function<int, n, counter3>);
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter3[i] == 1);
     }
   }
 
-  TEST_CASE("bulk can be used with a function object", "[adaptors][bulk]") {
-    constexpr int n = 9;
-    int counter[n]{0};
+  TEST_CASE("bulk can be used with a function object", "[adaptors][bulk]")
+  {
+    constexpr int          n = 9;
+    int                    counter[n]{0};
     function_object_t<int> fn{counter};
 
     ex::sender auto snd = ex::just() | ex::bulk(ex::par, n, fn);
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i: counter) {
+    for (int i: counter)
+    {
       CHECK(i == 1);
     }
   }
 
-  TEST_CASE("bulk_chunked can be used with a function object", "[adaptors][bulk]") {
-    constexpr int n = 9;
-    int counter[n]{0};
+  TEST_CASE("bulk_chunked can be used with a function object", "[adaptors][bulk]")
+  {
+    constexpr int                n = 9;
+    int                          counter[n]{0};
     function_object_range_t<int> fn{counter};
 
     ex::sender auto snd = ex::just() | ex::bulk_chunked(ex::par, n, fn);
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk_unchunked can be used with a function object", "[adaptors][bulk]") {
-    constexpr int n = 9;
-    int counter[n]{0};
+  TEST_CASE("bulk_unchunked can be used with a function object", "[adaptors][bulk]")
+  {
+    constexpr int          n = 9;
+    int                    counter[n]{0};
     function_object_t<int> fn{counter};
 
     ex::sender auto snd = ex::just() | ex::bulk_unchunked(ex::par, n, fn);
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk can be used with a lambda", "[adaptors][bulk]") {
+  TEST_CASE("bulk can be used with a lambda", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    int counter[n]{0};
+    int           counter[n]{0};
 
     ex::sender auto snd = ex::just() | ex::bulk(ex::par, n, [&](int i) { counter[i]++; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i: counter) {
+    for (int i: counter)
+    {
       CHECK(i == 1);
     }
   }
 
-  TEST_CASE("bulk_chunked can be used with a lambda", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked can be used with a lambda", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    int counter[n]{0};
+    int           counter[n]{0};
 
-    ex::sender auto snd = ex::just() | ex::bulk_chunked(ex::par, n, [&](int b, int e) {
-                            while (b < e)
-                              counter[b++]++;
-                          });
+    ex::sender auto snd = ex::just()
+                        | ex::bulk_chunked(ex::par,
+                                           n,
+                                           [&](int b, int e)
+                                           {
+                                             while (b < e)
+                                               counter[b++]++;
+                                           });
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk_unchunked can be used with a lambda", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked can be used with a lambda", "[adaptors][bulk]")
+  {
     constexpr int n = 9;
-    int counter[n]{0};
+    int           counter[n]{0};
 
     ex::sender auto snd = ex::just() | ex::bulk_unchunked(ex::par, n, [&](int i) { counter[i]++; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk works with all standard execution policies", "[adaptors][bulk]") {
-    ex::sender auto snd1 = ex::just() | ex::bulk(ex::seq, 9, [](int) { });
-    ex::sender auto snd2 = ex::just() | ex::bulk(ex::par, 9, [](int) { });
-    ex::sender auto snd3 = ex::just() | ex::bulk(ex::par_unseq, 9, [](int) { });
-    ex::sender auto snd4 = ex::just() | ex::bulk(ex::unseq, 9, [](int) { });
+  TEST_CASE("bulk works with all standard execution policies", "[adaptors][bulk]")
+  {
+    ex::sender auto snd1 = ex::just() | ex::bulk(ex::seq, 9, [](int) {});
+    ex::sender auto snd2 = ex::just() | ex::bulk(ex::par, 9, [](int) {});
+    ex::sender auto snd3 = ex::just() | ex::bulk(ex::par_unseq, 9, [](int) {});
+    ex::sender auto snd4 = ex::just() | ex::bulk(ex::unseq, 9, [](int) {});
 
     static_assert(ex::sender<decltype(snd1)>);
     static_assert(ex::sender<decltype(snd2)>);
@@ -376,11 +422,12 @@ namespace {
     (void) snd4;
   }
 
-  TEST_CASE("bulk_chunked works with all standard execution policies", "[adaptors][bulk]") {
-    ex::sender auto snd1 = ex::just() | ex::bulk_chunked(ex::seq, 9, [](int, int) { });
-    ex::sender auto snd2 = ex::just() | ex::bulk_chunked(ex::par, 9, [](int, int) { });
-    ex::sender auto snd3 = ex::just() | ex::bulk_chunked(ex::par_unseq, 9, [](int, int) { });
-    ex::sender auto snd4 = ex::just() | ex::bulk_chunked(ex::unseq, 9, [](int, int) { });
+  TEST_CASE("bulk_chunked works with all standard execution policies", "[adaptors][bulk]")
+  {
+    ex::sender auto snd1 = ex::just() | ex::bulk_chunked(ex::seq, 9, [](int, int) {});
+    ex::sender auto snd2 = ex::just() | ex::bulk_chunked(ex::par, 9, [](int, int) {});
+    ex::sender auto snd3 = ex::just() | ex::bulk_chunked(ex::par_unseq, 9, [](int, int) {});
+    ex::sender auto snd4 = ex::just() | ex::bulk_chunked(ex::unseq, 9, [](int, int) {});
 
     static_assert(ex::sender<decltype(snd1)>);
     static_assert(ex::sender<decltype(snd2)>);
@@ -392,110 +439,141 @@ namespace {
     (void) snd4;
   }
 
-  TEST_CASE("bulk forwards values", "[adaptors][bulk]") {
-    constexpr int n = 9;
+  TEST_CASE("bulk forwards values", "[adaptors][bulk]")
+  {
+    constexpr int n            = 9;
     constexpr int magic_number = 42;
-    int counter[n]{0};
+    int           counter[n]{0};
 
-    auto snd = ex::just(magic_number) | ex::bulk(ex::par, n, [&](int i, int val) {
-                 if (val == magic_number) {
-                   counter[i]++;
-                 }
-               });
+    auto snd = ex::just(magic_number)
+             | ex::bulk(ex::par,
+                        n,
+                        [&](int i, int val)
+                        {
+                          if (val == magic_number)
+                          {
+                            counter[i]++;
+                          }
+                        });
     auto op = ex::connect(std::move(snd), expect_value_receiver{magic_number});
     ex::start(op);
 
-    for (int i: counter) {
+    for (int i: counter)
+    {
       CHECK(i == 1);
     }
   }
 
-  TEST_CASE("bulk_chunked forwards values", "[adaptors][bulk]") {
-    constexpr int n = 9;
+  TEST_CASE("bulk_chunked forwards values", "[adaptors][bulk]")
+  {
+    constexpr int n            = 9;
     constexpr int magic_number = 42;
-    int counter[n]{0};
-
-    auto snd = ex::just(magic_number) | ex::bulk_chunked(ex::par, n, [&](int b, int e, int val) {
-                 if (val == magic_number) {
-                   while (b < e) {
-                     counter[b++]++;
-                   }
-                 }
-               });
+    int           counter[n]{0};
+
+    auto snd = ex::just(magic_number)
+             | ex::bulk_chunked(ex::par,
+                                n,
+                                [&](int b, int e, int val)
+                                {
+                                  if (val == magic_number)
+                                  {
+                                    while (b < e)
+                                    {
+                                      counter[b++]++;
+                                    }
+                                  }
+                                });
     auto op = ex::connect(std::move(snd), expect_value_receiver{magic_number});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk_unchunked forwards values", "[adaptors][bulk]") {
-    constexpr int n = 9;
+  TEST_CASE("bulk_unchunked forwards values", "[adaptors][bulk]")
+  {
+    constexpr int n            = 9;
     constexpr int magic_number = 42;
-    int counter[n]{0};
+    int           counter[n]{0};
 
-    auto snd = ex::just(magic_number) | ex::bulk_unchunked(ex::par, n, [&](int i, int val) {
-                 if (val == magic_number) {
-                   counter[i]++;
-                 }
-               });
+    auto snd = ex::just(magic_number)
+             | ex::bulk_unchunked(ex::par,
+                                  n,
+                                  [&](int i, int val)
+                                  {
+                                    if (val == magic_number)
+                                    {
+                                      counter[i]++;
+                                    }
+                                  });
     auto op = ex::connect(std::move(snd), expect_value_receiver{magic_number});
     ex::start(op);
 
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
       CHECK(counter[i] == 1);
     }
   }
 
-  TEST_CASE("bulk forwards values that can be taken by reference", "[adaptors][bulk]") {
+  TEST_CASE("bulk forwards values that can be taken by reference", "[adaptors][bulk]")
+  {
     constexpr std::size_t n = 9;
-    std::vector<int> vals(n, 0);
-    std::vector<int> vals_expected(n);
+    std::vector<int>      vals(n, 0);
+    std::vector<int>      vals_expected(n);
     std::iota(vals_expected.begin(), vals_expected.end(), 0);
 
     auto snd = ex::just(std::move(vals))
-             | ex::bulk(ex::par, n, [&](std::size_t i, std::vector<int>& vals) {
-                 vals[i] = static_cast<int>(i);
-               });
+             | ex::bulk(ex::par,
+                        n,
+                        [&](std::size_t i, std::vector<int>& vals)
+                        { vals[i] = static_cast<int>(i); });
     auto op = ex::connect(std::move(snd), expect_value_receiver{vals_expected});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_chunked forwards values that can be taken by reference", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked forwards values that can be taken by reference", "[adaptors][bulk]")
+  {
     constexpr std::size_t n = 9;
-    std::vector<int> vals(n, 0);
-    std::vector<int> vals_expected(n);
+    std::vector<int>      vals(n, 0);
+    std::vector<int>      vals_expected(n);
     std::iota(vals_expected.begin(), vals_expected.end(), 0);
 
-    auto snd =
-      ex::just(std::move(vals))
-      | ex::bulk_chunked(ex::par, n, [&](std::size_t b, std::size_t e, std::vector<int>& vals) {
-          for (; b < e; ++b) {
-            vals[b] = static_cast<int>(b);
-          }
-        });
+    auto snd = ex::just(std::move(vals))
+             | ex::bulk_chunked(ex::par,
+                                n,
+                                [&](std::size_t b, std::size_t e, std::vector<int>& vals)
+                                {
+                                  for (; b < e; ++b)
+                                  {
+                                    vals[b] = static_cast<int>(b);
+                                  }
+                                });
     auto op = ex::connect(std::move(snd), expect_value_receiver{vals_expected});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_unchunked forwards values that can be taken by reference", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked forwards values that can be taken by reference", "[adaptors][bulk]")
+  {
     constexpr std::size_t n = 9;
-    std::vector<int> vals(n, 0);
-    std::vector<int> vals_expected(n);
+    std::vector<int>      vals(n, 0);
+    std::vector<int>      vals_expected(n);
     std::iota(vals_expected.begin(), vals_expected.end(), 0);
 
     auto snd = ex::just(std::move(vals))
-             | ex::bulk_unchunked(ex::par, n, [&](std::size_t i, std::vector<int>& vals) {
-                 vals[i] = static_cast<int>(i);
-               });
+             | ex::bulk_unchunked(ex::par,
+                                  n,
+                                  [&](std::size_t i, std::vector<int>& vals)
+                                  { vals[i] = static_cast<int>(i); });
     auto op = ex::connect(std::move(snd), expect_value_receiver{vals_expected});
     ex::start(op);
   }
 
-  TEST_CASE("bulk cannot be used to change the value type", "[adaptors][bulk]") {
+  TEST_CASE("bulk cannot be used to change the value type", "[adaptors][bulk]")
+  {
     constexpr int magic_number = 42;
-    constexpr int n = 2;
+    constexpr int n            = 2;
 
     auto snd = ex::just(magic_number)
              | ex::bulk(ex::par, n, [](int, int) { return function_object_t<int>{nullptr}; });
@@ -504,40 +582,47 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("bulk_chunked cannot be used to change the value type", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked cannot be used to change the value type", "[adaptors][bulk]")
+  {
     constexpr int magic_number = 42;
-    constexpr int n = 2;
+    constexpr int n            = 2;
 
-    auto snd = ex::just(magic_number) | ex::bulk_chunked(ex::par, n, [](int, int, int) {
-                 return function_object_range_t<int>{nullptr};
-               });
+    auto snd = ex::just(magic_number)
+             | ex::bulk_chunked(ex::par,
+                                n,
+                                [](int, int, int)
+                                { return function_object_range_t<int>{nullptr}; });
 
     auto op = ex::connect(std::move(snd), expect_value_receiver{magic_number});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_unchunked cannot be used to change the value type", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked cannot be used to change the value type", "[adaptors][bulk]")
+  {
     constexpr int magic_number = 42;
-    constexpr int n = 2;
+    constexpr int n            = 2;
 
-    auto snd = ex::just(magic_number) | ex::bulk_unchunked(ex::par, n, [](int, int) {
-                 return function_object_t<int>{nullptr};
-               });
+    auto snd = ex::just(magic_number)
+             | ex::bulk_unchunked(ex::par,
+                                  n,
+                                  [](int, int) { return function_object_t<int>{nullptr}; });
 
     auto op = ex::connect(std::move(snd), expect_value_receiver{magic_number});
     ex::start(op);
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("bulk can throw, and set_error will be called", "[adaptors][bulk]") {
+  TEST_CASE("bulk can throw, and set_error will be called", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
 
     auto snd = ex::just() | ex::bulk(ex::par, n, [](int) -> int { throw std::logic_error{"err"}; });
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_chunked can throw, and set_error will be called", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked can throw, and set_error will be called", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
 
     auto snd = ex::just()
@@ -546,7 +631,8 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("bulk_unchunked can throw, and set_error will be called", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked can throw, and set_error will be called", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
 
     auto snd = ex::just()
@@ -554,11 +640,12 @@ namespace {
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("bulk function is not called on error", "[adaptors][bulk]") {
+  TEST_CASE("bulk function is not called on error", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_error(std::string{"err"})
              | ex::bulk(ex::par, n, [&called](int) { called++; });
@@ -566,9 +653,10 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("bulk_chunked function is not called on error", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked function is not called on error", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_error(std::string{"err"})
              | ex::bulk_chunked(ex::par, n, [&called](int, int) { called++; });
@@ -576,9 +664,10 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("bulk_unchunked function is not called on error", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked function is not called on error", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_error(std::string{"err"})
              | ex::bulk_unchunked(ex::par, n, [&called](int) { called++; });
@@ -586,39 +675,45 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("bulk function in not called on stop", "[adaptors][bulk]") {
+  TEST_CASE("bulk function in not called on stop", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_stopped() | ex::bulk(ex::par, n, [&called](int) { called++; });
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_chunked function in not called on stop", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked function in not called on stop", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_stopped() | ex::bulk_chunked(ex::par, n, [&called](int, int) { called++; });
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("bulk_unchunked function in not called on stop", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked function in not called on stop", "[adaptors][bulk]")
+  {
     constexpr int n = 2;
-    int called{};
+    int           called{};
 
     auto snd = ex::just_stopped() | ex::bulk_unchunked(ex::par, n, [&called](int) { called++; });
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("bulk works with static thread pool", "[adaptors][bulk]") {
+  TEST_CASE("bulk works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
-      for (std::size_t n = 0; n < 9u; n++) {
+    SECTION("Without values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < 9u; n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just() | ex::continues_on(sch)
@@ -626,57 +721,67 @@ namespace {
                  | ex::bulk(ex::par, n, [&counter](std::size_t idx) { counter[idx]++; });
         ex::sync_wait(std::move(snd));
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel") {
-      for (std::size_t n = 0; n < 9; n++) {
+    SECTION("With values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < 9; n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just(42) | ex::continues_on(sch)
-                 | ex::bulk(
-                     ex::par,
-                     n,
-                     [&counter](std::size_t idx, int val) {
-                       if (val == 42) {
-                         counter[idx] = 0;
-                       }
-                     })
-                 | ex::bulk(ex::par, n, [&counter](std::size_t idx, int val) {
-                     if (val == 42) {
-                       counter[idx]++;
-                     }
-                   });
+                 | ex::bulk(ex::par,
+                            n,
+                            [&counter](std::size_t idx, int val)
+                            {
+                              if (val == 42)
+                              {
+                                counter[idx] = 0;
+                              }
+                            })
+                 | ex::bulk(ex::par,
+                            n,
+                            [&counter](std::size_t idx, int val)
+                            {
+                              if (val == 42)
+                              {
+                                counter[idx]++;
+                              }
+                            });
         auto [val] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(val == 42);
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel that can be taken by reference") {
-      for (std::size_t n = 0; n < 9; n++) {
+    SECTION("With values in the set_value channel that can be taken by reference")
+    {
+      for (std::size_t n = 0; n < 9; n++)
+      {
         std::vector<int> vals(n, 0);
         std::vector<int> vals_expected(n);
         std::iota(vals_expected.begin(), vals_expected.end(), 1);
 
-        auto snd =
-          ex::just(std::move(vals)) | ex::continues_on(sch)
-          | ex::bulk(
-            ex::par,
-            n,
-            [](std::size_t idx, std::vector<int>& vals) { vals[idx] = static_cast<int>(idx); })
-          | ex::bulk(ex::par, n, [](std::size_t idx, std::vector<int>& vals) { ++vals[idx]; });
+        auto snd = ex::just(std::move(vals)) | ex::continues_on(sch)
+                 | ex::bulk(ex::par,
+                            n,
+                            [](std::size_t idx, std::vector<int>& vals)
+                            { vals[idx] = static_cast<int>(idx); })
+                 | ex::bulk(ex::par,
+                            n,
+                            [](std::size_t idx, std::vector<int>& vals) { ++vals[idx]; });
         auto [vals_actual] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(vals_actual == vals_expected);
@@ -684,19 +789,21 @@ namespace {
     }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-    SECTION("With exception") {
-      constexpr int n = 9;
-      auto snd = ex::just() | ex::continues_on(sch)
+    SECTION("With exception")
+    {
+      constexpr int n   = 9;
+      auto          snd = ex::just() | ex::continues_on(sch)
                | ex::bulk(ex::par, n, [](int) { throw std::runtime_error("bulk"); });
 
       CHECK_THROWS_AS(ex::sync_wait(std::move(snd)), std::runtime_error);
     }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-    SECTION("With concurrent enqueueing") {
+    SECTION("With concurrent enqueueing")
+    {
       constexpr std::size_t n = 4;
-      std::vector<int> counters_1(n, 0);
-      std::vector<int> counters_2(n, 0);
+      std::vector<int>      counters_1(n, 0);
+      std::vector<int>      counters_2(n, 0);
 
       ex::sender auto snd = ex::when_all(
         ex::schedule(sch) | ex::bulk(ex::par, n, [&](std::size_t id) { counters_1[id]++; }),
@@ -709,89 +816,107 @@ namespace {
     }
   }
 
-  TEST_CASE("bulk_chunked works with static thread pool", "[adaptors][bulk]") {
+  TEST_CASE("bulk_chunked works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
-      for (std::size_t n = 0; n < 9u; n++) {
+    SECTION("Without values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < 9u; n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just() | ex::continues_on(sch)
-                 | ex::bulk_chunked(
-                     ex::par,
-                     n,
-                     [&counter](std::size_t b, std::size_t e) {
-                       while (b < e)
-                         counter[b++] = 0;
-                     })
-                 | ex::bulk_chunked(ex::par, n, [&counter](std::size_t b, std::size_t e) {
-                     while (b < e)
-                       counter[b++]++;
-                   });
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [&counter](std::size_t b, std::size_t e)
+                                    {
+                                      while (b < e)
+                                        counter[b++] = 0;
+                                    })
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [&counter](std::size_t b, std::size_t e)
+                                    {
+                                      while (b < e)
+                                        counter[b++]++;
+                                    });
         ex::sync_wait(std::move(snd));
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel") {
-      for (std::size_t n = 0; n < 9; n++) {
+    SECTION("With values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < 9; n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just(42) | ex::continues_on(sch)
-                 | ex::bulk_chunked(
-                     ex::par,
-                     n,
-                     [&counter](std::size_t b, std::size_t e, int val) {
-                       if (val == 42) {
-                         while (b < e)
-                           counter[b++] = 0;
-                       }
-                     })
-                 | ex::bulk_chunked(ex::par, n, [&counter](std::size_t b, std::size_t e, int val) {
-                     if (val == 42) {
-                       while (b < e)
-                         counter[b++]++;
-                     }
-                   });
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [&counter](std::size_t b, std::size_t e, int val)
+                                    {
+                                      if (val == 42)
+                                      {
+                                        while (b < e)
+                                          counter[b++] = 0;
+                                      }
+                                    })
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [&counter](std::size_t b, std::size_t e, int val)
+                                    {
+                                      if (val == 42)
+                                      {
+                                        while (b < e)
+                                          counter[b++]++;
+                                      }
+                                    });
         auto [val] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(val == 42);
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel that can be taken by reference") {
-      for (std::size_t n = 0; n < 9; n++) {
+    SECTION("With values in the set_value channel that can be taken by reference")
+    {
+      for (std::size_t n = 0; n < 9; n++)
+      {
         std::vector<int> vals(n, 0);
         std::vector<int> vals_expected(n);
         std::iota(vals_expected.begin(), vals_expected.end(), 1);
 
-        auto snd =
-          ex::just(std::move(vals)) | ex::continues_on(sch)
-          | ex::bulk_chunked(
-            ex::par,
-            n,
-            [](std::size_t b, std::size_t e, std::vector<int>& vals) {
-              while (b < e) {
-                vals[b] = static_cast<int>(b);
-                ++b;
-              }
-            })
-          | ex::bulk_chunked(ex::par, n, [](std::size_t b, std::size_t e, std::vector<int>& vals) {
-              while (b < e)
-                ++vals[b++];
-            });
+        auto snd = ex::just(std::move(vals)) | ex::continues_on(sch)
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [](std::size_t b, std::size_t e, std::vector<int>& vals)
+                                    {
+                                      while (b < e)
+                                      {
+                                        vals[b] = static_cast<int>(b);
+                                        ++b;
+                                      }
+                                    })
+                 | ex::bulk_chunked(ex::par,
+                                    n,
+                                    [](std::size_t b, std::size_t e, std::vector<int>& vals)
+                                    {
+                                      while (b < e)
+                                        ++vals[b++];
+                                    });
         auto [vals_actual] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(vals_actual == vals_expected);
@@ -799,34 +924,40 @@ namespace {
     }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-    SECTION("With exception") {
-      constexpr int n = 9;
-      auto snd = ex::just() | ex::continues_on(sch) | ex::bulk_chunked(ex::par, n, [](int, int) {
-                   throw std::runtime_error("bulk_chunked");
-                 });
+    SECTION("With exception")
+    {
+      constexpr int n   = 9;
+      auto          snd = ex::just() | ex::continues_on(sch)
+               | ex::bulk_chunked(ex::par,
+                                  n,
+                                  [](int, int) { throw std::runtime_error("bulk_chunked"); });
 
       CHECK_THROWS_AS(ex::sync_wait(std::move(snd)), std::runtime_error);
     }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-    SECTION("With concurrent enqueueing") {
+    SECTION("With concurrent enqueueing")
+    {
       constexpr std::size_t n = 4;
-      std::vector<int> counters_1(n, 0);
-      std::vector<int> counters_2(n, 0);
-
-      ex::sender auto snd = ex::when_all(
-        ex::schedule(sch)
-          | ex::bulk_chunked(
-            ex::par,
-            n,
-            [&](std::size_t b, std::size_t e) {
-              while (b < e)
-                counters_1[b++]++;
-            }),
-        ex::schedule(sch) | ex::bulk_chunked(ex::par, n, [&](std::size_t b, std::size_t e) {
-          while (b < e)
-            counters_2[b++]++;
-        }));
+      std::vector<int>      counters_1(n, 0);
+      std::vector<int>      counters_2(n, 0);
+
+      ex::sender auto snd = ex::when_all(ex::schedule(sch)
+                                           | ex::bulk_chunked(ex::par,
+                                                              n,
+                                                              [&](std::size_t b, std::size_t e)
+                                                              {
+                                                                while (b < e)
+                                                                  counters_1[b++]++;
+                                                              }),
+                                         ex::schedule(sch)
+                                           | ex::bulk_chunked(ex::par,
+                                                              n,
+                                                              [&](std::size_t b, std::size_t e)
+                                                              {
+                                                                while (b < e)
+                                                                  counters_2[b++]++;
+                                                              }));
 
       ex::sync_wait(std::move(snd));
 
@@ -835,12 +966,15 @@ namespace {
     }
   }
 
-  TEST_CASE("bulk_unchunked works with static thread pool", "[adaptors][bulk]") {
+  TEST_CASE("bulk_unchunked works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
-      for (std::size_t n = 0; n < pool.available_parallelism(); n++) {
+    SECTION("Without values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < pool.available_parallelism(); n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just() | ex::continues_on(sch)
@@ -848,60 +982,67 @@ namespace {
                  | ex::bulk_unchunked(ex::par, n, [&counter](std::size_t idx) { counter[idx]++; });
         ex::sync_wait(std::move(snd));
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel") {
-      for (std::size_t n = 0; n < pool.available_parallelism(); n++) {
+    SECTION("With values in the set_value channel")
+    {
+      for (std::size_t n = 0; n < pool.available_parallelism(); n++)
+      {
         std::vector<int> counter(n, 42);
 
         auto snd = ex::just(42) | ex::continues_on(sch)
-                 | ex::bulk_unchunked(
-                     ex::par,
-                     n,
-                     [&counter](std::size_t idx, int val) {
-                       if (val == 42) {
-                         counter[idx] = 0;
-                       }
-                     })
-                 | ex::bulk_unchunked(ex::par, n, [&counter](std::size_t idx, int val) {
-                     if (val == 42) {
-                       counter[idx]++;
-                     }
-                   });
+                 | ex::bulk_unchunked(ex::par,
+                                      n,
+                                      [&counter](std::size_t idx, int val)
+                                      {
+                                        if (val == 42)
+                                        {
+                                          counter[idx] = 0;
+                                        }
+                                      })
+                 | ex::bulk_unchunked(ex::par,
+                                      n,
+                                      [&counter](std::size_t idx, int val)
+                                      {
+                                        if (val == 42)
+                                        {
+                                          counter[idx]++;
+                                        }
+                                      });
         auto [val] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(val == 42);
 
-        const std::size_t actual = static_cast<std::size_t>(
+        std::size_t const actual = static_cast<std::size_t>(
           std::count(counter.begin(), counter.end(), 1));
-        const std::size_t expected = n;
+        std::size_t const expected = n;
 
         CHECK(expected == actual);
       }
     }
 
-    SECTION("With values in the set_value channel that can be taken by reference") {
-      for (std::size_t n = 0; n < pool.available_parallelism(); n++) {
+    SECTION("With values in the set_value channel that can be taken by reference")
+    {
+      for (std::size_t n = 0; n < pool.available_parallelism(); n++)
+      {
         std::vector<int> vals(n, 0);
         std::vector<int> vals_expected(n);
         std::iota(vals_expected.begin(), vals_expected.end(), 1);
 
         auto snd = ex::just(std::move(vals)) | ex::continues_on(sch)
-                 | ex::bulk_unchunked(
-                     ex::par,
-                     n,
-                     [](std::size_t idx, std::vector<int>& vals) {
-                       vals[idx] = static_cast<int>(idx);
-                     })
-                 | ex::bulk_unchunked(ex::par, n, [](std::size_t idx, std::vector<int>& vals) {
-                     ++vals[idx];
-                   });
+                 | ex::bulk_unchunked(ex::par,
+                                      n,
+                                      [](std::size_t idx, std::vector<int>& vals)
+                                      { vals[idx] = static_cast<int>(idx); })
+                 | ex::bulk_unchunked(ex::par,
+                                      n,
+                                      [](std::size_t idx, std::vector<int>& vals) { ++vals[idx]; });
         auto [vals_actual] = ex::sync_wait(std::move(snd)).value();
 
         CHECK(vals_actual == vals_expected);
@@ -909,26 +1050,29 @@ namespace {
     }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-    SECTION("With exception") {
-      auto const n = pool.available_parallelism();
-      auto snd = ex::just() | ex::continues_on(sch) | ex::bulk_unchunked(ex::par, n, [](int) {
-                   throw std::runtime_error("bulk_unchunked");
-                 });
+    SECTION("With exception")
+    {
+      auto const n   = pool.available_parallelism();
+      auto       snd = ex::just() | ex::continues_on(sch)
+               | ex::bulk_unchunked(ex::par,
+                                    n,
+                                    [](int) { throw std::runtime_error("bulk_unchunked"); });
 
       CHECK_THROWS_AS(ex::sync_wait(std::move(snd)), std::runtime_error);
     }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-    SECTION("With concurrent enqueueing") {
-      auto const n = pool.available_parallelism();
+    SECTION("With concurrent enqueueing")
+    {
+      auto const       n = pool.available_parallelism();
       std::vector<int> counters_1(n, 0);
       std::vector<int> counters_2(n, 0);
 
-      ex::sender auto snd = ex::when_all(
-        ex::schedule(sch)
-          | ex::bulk_unchunked(ex::par, n, [&](std::size_t id) { counters_1[id]++; }),
-        ex::schedule(sch)
-          | ex::bulk_unchunked(ex::par, n, [&](std::size_t id) { counters_2[id]++; }));
+      ex::sender auto snd =
+        ex::when_all(ex::schedule(sch)
+                       | ex::bulk_unchunked(ex::par, n, [&](std::size_t id) { counters_1[id]++; }),
+                     ex::schedule(sch)
+                       | ex::bulk_unchunked(ex::par, n, [&](std::size_t id) { counters_2[id]++; }));
 
       ex::sync_wait(std::move(snd));
 
@@ -937,14 +1081,17 @@ namespace {
     }
   }
 
-  TEST_CASE("eager customization of bulk works with static thread pool", "[adaptors][bulk]") {
+  TEST_CASE("eager customization of bulk works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
+    SECTION("Without values in the set_value channel")
+    {
       std::vector<std::thread::id> tids(42);
 
-      auto fun = [&tids](std::size_t idx) {
+      auto fun = [&tids](std::size_t idx)
+      {
         tids[idx] = std::this_thread::get_id();
         std::this_thread::sleep_for(std::chrono::milliseconds{10});
       };
@@ -953,24 +1100,26 @@ namespace {
       ex::sync_wait(std::move(snd));
 
       // All the work should not have run on the same thread
-      const auto actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
-      const std::size_t wrong = tids.size();
+      auto const actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
+      std::size_t const wrong = tids.size();
 
       CHECK(actual != wrong);
     }
   }
 
-  TEST_CASE(
-    "eager customization of bulk_chunked works with static thread pool",
-    "[adaptors][bulk]") {
+  TEST_CASE("eager customization of bulk_chunked works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
+    SECTION("Without values in the set_value channel")
+    {
       std::vector<std::thread::id> tids(42);
 
-      auto fun = [&tids](std::size_t b, std::size_t e) {
-        while (b < e) {
+      auto fun = [&tids](std::size_t b, std::size_t e)
+      {
+        while (b < e)
+        {
           tids[b++] = std::this_thread::get_id();
         }
         std::this_thread::sleep_for(std::chrono::milliseconds{10});
@@ -980,21 +1129,24 @@ namespace {
       ex::sync_wait(std::move(snd));
 
       // All the work should not have run on the same thread
-      const auto actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
-      const std::size_t wrong = tids.size();
+      auto const actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
+      std::size_t const wrong = tids.size();
 
       CHECK(actual != wrong);
     }
   }
 
-  TEST_CASE("lazy customization of bulk works with static thread pool", "[adaptors][bulk]") {
+  TEST_CASE("lazy customization of bulk works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
+    SECTION("Without values in the set_value channel")
+    {
       std::vector<std::thread::id> tids(42);
 
-      auto fun = [&tids](std::size_t idx) {
+      auto fun = [&tids](std::size_t idx)
+      {
         tids[idx] = std::this_thread::get_id();
         std::this_thread::sleep_for(std::chrono::milliseconds{10});
       };
@@ -1003,24 +1155,26 @@ namespace {
       ex::sync_wait(ex::starts_on(sch, std::move(snd)));
 
       // All the work should not have run on the same thread
-      const auto actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
-      const std::size_t wrong = tids.size();
+      auto const actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
+      std::size_t const wrong = tids.size();
 
       CHECK(actual != wrong);
     }
   }
 
-  TEST_CASE(
-    "lazy customization of bulk_chunked works with static thread pool",
-    "[adaptors][bulk]") {
+  TEST_CASE("lazy customization of bulk_chunked works with static thread pool", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("Without values in the set_value channel") {
+    SECTION("Without values in the set_value channel")
+    {
       std::vector<std::thread::id> tids(42);
 
-      auto fun = [&tids](std::size_t b, std::size_t e) {
-        while (b < e) {
+      auto fun = [&tids](std::size_t b, std::size_t e)
+      {
+        while (b < e)
+        {
           tids[b++] = std::this_thread::get_id();
         }
         std::this_thread::sleep_for(std::chrono::milliseconds{10});
@@ -1030,46 +1184,50 @@ namespace {
       ex::sync_wait(ex::starts_on(sch, std::move(snd)));
 
       // All the work should not have run on the same thread
-      const auto actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
-      const std::size_t wrong = tids.size();
+      auto const actual = static_cast<std::size_t>(std::count(tids.begin(), tids.end(), tids[0]));
+      std::size_t const wrong = tids.size();
 
       CHECK(actual != wrong);
     }
   }
 
-  TEST_CASE("default bulk works with non-default constructible types", "[adaptors][bulk]") {
+  TEST_CASE("default bulk works with non-default constructible types", "[adaptors][bulk]")
+  {
     ex::sender auto s = ex::just(non_default_constructible{42})
-                      | ex::bulk(ex::par, 1, [](int, auto&) { });
+                      | ex::bulk(ex::par, 1, [](int, auto&) {});
     ex::sync_wait(std::move(s));
   }
 
-  TEST_CASE("default bulk_chunked works with non-default constructible types", "[adaptors][bulk]") {
+  TEST_CASE("default bulk_chunked works with non-default constructible types", "[adaptors][bulk]")
+  {
     ex::sender auto s = ex::just(non_default_constructible{42})
-                      | ex::bulk_chunked(ex::par, 1, [](int, int, auto&) { });
+                      | ex::bulk_chunked(ex::par, 1, [](int, int, auto&) {});
     ex::sync_wait(std::move(s));
   }
 
-  TEST_CASE(
-    "default bulk_unchunked works with non-default constructible types",
-    "[adaptors][bulk]") {
+  TEST_CASE("default bulk_unchunked works with non-default constructible types", "[adaptors][bulk]")
+  {
     ex::sender auto s = ex::just(non_default_constructible{42})
-                      | ex::bulk_unchunked(ex::par, 1, [](int, auto&) { });
+                      | ex::bulk_unchunked(ex::par, 1, [](int, auto&) {});
     ex::sync_wait(std::move(s));
   }
 
-  TEST_CASE("static thread pool works with non-default constructible types", "[adaptors][bulk]") {
+  TEST_CASE("static thread pool works with non-default constructible types", "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
     ex::sender auto s = ex::just(non_default_constructible{42}) | ex::continues_on(sch)
-                      | ex::bulk(ex::par, 1, [](int, auto&) { });
+                      | ex::bulk(ex::par, 1, [](int, auto&) {});
     ex::sync_wait(std::move(s));
   }
 
   template <class Sched, class Policy>
-  int number_of_threads_in_bulk(Sched sch, const Policy& policy, int n) {
+  int number_of_threads_in_bulk(Sched sch, Policy const & policy, int n)
+  {
     std::vector<std::thread::id> tids(n);
-    auto fun = [&tids](std::size_t idx) {
+    auto                         fun = [&tids](std::size_t idx)
+    {
       tids[idx] = std::this_thread::get_id();
       std::this_thread::sleep_for(std::chrono::milliseconds{10});
     };
@@ -1081,30 +1239,36 @@ namespace {
     return static_cast<int>(std::unique(tids.begin(), tids.end()) - tids.begin());
   }
 
-  TEST_CASE(
-    "static thread pool execute bulk work in accordance with the execution policy",
-    "[adaptors][bulk]") {
+  TEST_CASE("static thread pool execute bulk work in accordance with the execution policy",
+            "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("seq execution policy") {
+    SECTION("seq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk(sch, ex::seq, 42) == 1);
     }
-    SECTION("unseq execution policy") {
+    SECTION("unseq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk(sch, ex::unseq, 42) == 1);
     }
-    SECTION("par execution policy") {
+    SECTION("par execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk(sch, ex::par, 42) > 1);
     }
-    SECTION("par_unseq execution policy") {
+    SECTION("par_unseq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk(sch, ex::par_unseq, 42) > 1);
     }
   }
 
   template <class Sched, class Policy>
-  int number_of_threads_in_bulk_chunked(Sched sch, const Policy& policy, int n) {
+  int number_of_threads_in_bulk_chunked(Sched sch, Policy const & policy, int n)
+  {
     std::vector<std::thread::id> tids(n);
-    auto fun = [&tids](std::size_t b, std::size_t e) {
+    auto                         fun = [&tids](std::size_t b, std::size_t e)
+    {
       while (b < e)
         tids[b++] = std::this_thread::get_id();
       std::this_thread::sleep_for(std::chrono::milliseconds{10});
@@ -1117,51 +1281,61 @@ namespace {
     return static_cast<int>(std::unique(tids.begin(), tids.end()) - tids.begin());
   }
 
-  TEST_CASE(
-    "static thread pool execute bulk_chunked work in accordance with the execution policy",
-    "[adaptors][bulk]") {
+  TEST_CASE("static thread pool execute bulk_chunked work in accordance with the execution policy",
+            "[adaptors][bulk]")
+  {
     exec::static_thread_pool pool{4};
-    ex::scheduler auto sch = pool.get_scheduler();
+    ex::scheduler auto       sch = pool.get_scheduler();
 
-    SECTION("seq execution policy") {
+    SECTION("seq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk_chunked(sch, ex::seq, 42) == 1);
     }
-    SECTION("unseq execution policy") {
+    SECTION("unseq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk_chunked(sch, ex::unseq, 42) == 1);
     }
-    SECTION("par execution policy") {
+    SECTION("par execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk_chunked(sch, ex::par, 42) > 1);
     }
-    SECTION("par_unseq execution policy") {
+    SECTION("par_unseq execution policy")
+    {
       REQUIRE(number_of_threads_in_bulk_chunked(sch, ex::par_unseq, 42) > 1);
     }
   }
 
-  struct my_domain {
+  struct my_domain
+  {
     template <ex::sender_expr_for<ex::bulk_chunked_t> Sender, class... Env>
-    static auto transform_sender(STDEXEC::set_value_t, Sender, const Env&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender, Env const &...)
+    {
       return ex::just(std::string{"hijacked"});
     }
   };
 
-  TEST_CASE("late customizing bulk_chunked also changes the behavior of bulk", "[adaptors][then]") {
+  TEST_CASE("late customizing bulk_chunked also changes the behavior of bulk", "[adaptors][then]")
+  {
     bool called{false};
     // The customization will return a different value
     basic_inline_scheduler<my_domain> sched;
-    auto snd = ex::just(std::string{"hello"})
+    auto                              snd = ex::just(std::string{"hello"})
              | ex::on(sched, ex::bulk(ex::par, 1, [&called](int, std::string) { called = true; }));
     wait_for_value(std::move(snd), std::string{"hijacked"});
     REQUIRE_FALSE(called);
   }
 
-  struct my_domain2 {
+  struct my_domain2
+  {
     template <ex::sender_expr_for<ex::bulk_t> Sender, class... Env>
-    static auto transform_sender(STDEXEC::set_value_t, Sender, const Env&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender, Env const &...)
+    {
       return ex::just(std::string{"hijacked"});
     }
   };
 
-  TEST_CASE("bulk can be customized, independently of bulk_chunked", "[adaptors][then]") {
+  TEST_CASE("bulk can be customized, independently of bulk_chunked", "[adaptors][then]")
+  {
     bool called{false};
     // The customization will return a different value
     basic_inline_scheduler<my_domain2> sched;
@@ -1176,4 +1350,4 @@ namespace {
     wait_for_value(std::move(snd2), std::string{"hello"});
     REQUIRE(called);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_continues_on.cpp b/test/stdexec/algos/adaptors/test_continues_on.cpp
index f9fbed8af..4980aeaca 100644
--- a/test/stdexec/algos/adaptors/test_continues_on.cpp
+++ b/test/stdexec/algos/adaptors/test_continues_on.cpp
@@ -22,39 +22,44 @@
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono> // IWYU pragma: keep for chrono_literals
+#include <chrono>  // IWYU pragma: keep for chrono_literals
 
 namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("continues_on returns a sender", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on returns a sender", "[adaptors][continues_on]")
+  {
     auto snd = ex::continues_on(ex::just(13), inline_scheduler{});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("continues_on with environment returns a sender", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on with environment returns a sender", "[adaptors][continues_on]")
+  {
     auto snd = ex::continues_on(ex::just(13), inline_scheduler{});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("continues_on simple example", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on simple example", "[adaptors][continues_on]")
+  {
     auto snd = ex::continues_on(ex::just(13), inline_scheduler{});
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("continues_on can be piped", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on can be piped", "[adaptors][continues_on]")
+  {
     // Just transfer a value to the impulse scheduler
     ex::scheduler auto sched = impulse_scheduler{};
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched);
+    ex::sender auto    snd   = ex::just(13) | ex::continues_on(sched);
     // Start the operation
-    int res{0};
+    int  res{0};
     auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
     ex::start(op);
 
@@ -64,13 +69,13 @@ namespace {
     REQUIRE(res == 13);
   }
 
-  TEST_CASE(
-    "continues_on calls the receiver when the scheduler dictates",
-    "[adaptors][continues_on]") {
-    int recv_value{0};
+  TEST_CASE("continues_on calls the receiver when the scheduler dictates",
+            "[adaptors][continues_on]")
+  {
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto snd = ex::continues_on(ex::just(13), sched);
-    auto op = ex::connect(snd, expect_value_receiver_ex{recv_value});
+    auto              snd = ex::continues_on(ex::just(13), sched);
+    auto              op  = ex::connect(snd, expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task; no effect expected
     CHECK(recv_value == 0);
@@ -80,19 +85,22 @@ namespace {
     CHECK(recv_value == 13);
   }
 
-  TEST_CASE(
-    "continues_on calls the given sender when the scheduler dictates",
-    "[adaptors][continues_on]") {
+  TEST_CASE("continues_on calls the given sender when the scheduler dictates",
+            "[adaptors][continues_on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::then([&]() -> int {
-                      called = true;
-                      return 19;
-                    });
-
-    int recv_value{0};
+    auto snd_base = ex::just()
+                  | ex::then(
+                      [&]() -> int
+                      {
+                        called = true;
+                        return 19;
+                      });
+
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto snd = ex::continues_on(std::move(snd_base), sched);
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto              snd = ex::continues_on(std::move(snd_base), sched);
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // The sender is started, even if the scheduler hasn't yet triggered
     CHECK(called);
@@ -107,9 +115,10 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE("continues_on works when changing threads", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on works when changing threads", "[adaptors][continues_on]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // lunch some work on the thread pool
       ex::sender auto snd = ex::continues_on(ex::just(), pool.get_scheduler())
@@ -119,63 +128,70 @@ namespace {
     // wait for the work to be executed, with timeout
     // perform a poor-man's sync
     // NOTE: it's a shame that the `join` method in static_thread_pool is not public
-    for (int i = 0; i < 1000 && !called.load(); i++) {
+    for (int i = 0; i < 1000 && !called.load(); i++)
+    {
       std::this_thread::sleep_for(1ms);
     }
     // the work should be executed
     REQUIRE(called);
   }
 
-  TEST_CASE("continues_on can be called with rvalue ref scheduler", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on can be called with rvalue ref scheduler", "[adaptors][continues_on]")
+  {
     auto snd = ex::continues_on(ex::just(13), inline_scheduler{});
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("continues_on can be called with const ref scheduler", "[adaptors][continues_on]") {
-    const inline_scheduler sched;
-    auto snd = ex::continues_on(ex::just(13), sched);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+  TEST_CASE("continues_on can be called with const ref scheduler", "[adaptors][continues_on]")
+  {
+    inline_scheduler const sched;
+    auto                   snd = ex::continues_on(ex::just(13), sched);
+    auto                   op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("continues_on can be called with ref scheduler", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on can be called with ref scheduler", "[adaptors][continues_on]")
+  {
     inline_scheduler sched;
-    auto snd = ex::continues_on(ex::just(13), sched);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto             snd = ex::continues_on(ex::just(13), sched);
+    auto             op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("continues_on forwards set_error calls", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on forwards set_error calls", "[adaptors][continues_on]")
+  {
     error_scheduler<std::exception_ptr> sched{std::exception_ptr{}};
-    auto snd = ex::continues_on(ex::just(13), sched);
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto                                snd = ex::continues_on(ex::just(13), sched);
+    auto                                op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("continues_on forwards set_error calls of other types", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on forwards set_error calls of other types", "[adaptors][continues_on]")
+  {
     error_scheduler<std::string> sched{std::string{"error"}};
-    auto snd = ex::continues_on(ex::just(13), sched);
+    auto                         snd = ex::continues_on(ex::just(13), sched);
     auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"error"}});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("continues_on forwards set_stopped calls", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on forwards set_stopped calls", "[adaptors][continues_on]")
+  {
     stopped_scheduler sched{};
-    auto snd = ex::continues_on(ex::just(13), sched);
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto              snd = ex::continues_on(ex::just(13), sched);
+    auto              op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     // The receiver checks if we receive the stopped signal
   }
 
-  TEST_CASE(
-    "continues_on has the values_type corresponding to the given values",
-    "[adaptors][continues_on]") {
+  TEST_CASE("continues_on has the values_type corresponding to the given values",
+            "[adaptors][continues_on]")
+  {
     inline_scheduler sched{};
 
     check_val_types<ex::__mset<pack<int>>>(ex::continues_on(ex::just(1), sched));
@@ -184,9 +200,10 @@ namespace {
       ex::continues_on(ex::just(3, 0.14, std::string{"pi"}), sched));
   }
 
-  TEST_CASE("continues_on keeps error_types from scheduler's sender", "[adaptors][continues_on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("continues_on keeps error_types from scheduler's sender", "[adaptors][continues_on]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     check_err_types<ex::__mset<>>(ex::continues_on(ex::just(1), sched1));
@@ -194,20 +211,20 @@ namespace {
     check_err_types<ex::__mset<int>>(ex::continues_on(ex::just(3), sched3));
   }
 
-  TEST_CASE(
-    "continues_on sends an exception_ptr if value types are potentially throwing when copied",
-    "[adaptors][continues_on]") {
+  TEST_CASE("continues_on sends an exception_ptr if value types are potentially throwing when "
+            "copied",
+            "[adaptors][continues_on]")
+  {
     inline_scheduler sched{};
 
     check_err_types<ex::__mset<std::exception_ptr>>(
       ex::continues_on(ex::just(potentially_throwing{}), sched));
   }
 
-  TEST_CASE(
-    "continues_on keeps sends_stopped from scheduler's sender",
-    "[adaptors][continues_on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("continues_on keeps sends_stopped from scheduler's sender", "[adaptors][continues_on]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::continues_on(ex::just(1), sched1));
@@ -215,7 +232,8 @@ namespace {
     check_sends_stopped<true>(ex::continues_on(ex::just(3), sched3));
   }
 
-  struct value_type {
+  struct value_type
+  {
     int val_;
   };
 
@@ -223,49 +241,56 @@ namespace {
   using value_type_of_t =
     ex::value_types_of_t<Sender, ex::env<>, std::type_identity_t, std::type_identity_t>;
 
-  struct continues_on_test_domain {
+  struct continues_on_test_domain
+  {
     template <ex::sender_expr_for<ex::continues_on_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, const auto&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender &&, auto const &...)
+    {
       return ex::just(value_type{53});
     }
   };
 
-  TEST_CASE("continues_on can be customized early", "[adaptors][continues_on]") {
+  TEST_CASE("continues_on can be customized early", "[adaptors][continues_on]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<continues_on_test_domain> sched;
-    auto snd = ex::continues_on(ex::just(value_type{1}), sched);
+    auto       snd = ex::continues_on(ex::just(value_type{1}), sched);
     value_type res{0};
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
+    auto       op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
     ex::start(op);
     REQUIRE(res.val_ == 53);
   }
 
-  struct test_domain_A {
+  struct test_domain_A
+  {
     template <ex::sender_expr_for<ex::continues_on_t> Sender, class Env>
-    auto transform_sender(STDEXEC::set_value_t, Sender&&, Env&&) const {
+    auto transform_sender(STDEXEC::set_value_t, Sender &&, Env &&) const
+    {
       return ex::just(std::string("hello"));
     }
   };
 
-  struct test_domain_B {
+  struct test_domain_B
+  {
     template <ex::sender_expr_for<ex::continues_on_t> Sender, class Env>
-    auto transform_sender(STDEXEC::set_value_t, Sender&&, Env&&) const {
+    auto transform_sender(STDEXEC::set_value_t, Sender &&, Env &&) const
+    {
       return ex::just(std::string("goodbye"));
     }
   };
 
-  TEST_CASE(
-    "continues_on late customization is based on the scheduler's domain",
-    "[adaptors][continues_on]") {
+  TEST_CASE("continues_on late customization is based on the scheduler's domain",
+            "[adaptors][continues_on]")
+  {
     // The customization will return a different value
     ex::scheduler auto sched_A = basic_inline_scheduler<test_domain_A>{};
     ex::scheduler auto sched_B = basic_inline_scheduler<test_domain_B>{};
-    auto snd = ex::just(std::string("meow")) //
-             | ex::continues_on(sched_A)     //
+    auto               snd     = ex::just(std::string("meow"))  //
+             | ex::continues_on(sched_A)                        //
              | ex::continues_on(sched_B);
     std::string res;
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
+    auto        op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
     ex::start(op);
     REQUIRE(res == "goodbye");
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_finally.cpp b/test/stdexec/algos/adaptors/test_finally.cpp
index b86ad7bea..83e16a01a 100644
--- a/test/stdexec/algos/adaptors/test_finally.cpp
+++ b/test/stdexec/algos/adaptors/test_finally.cpp
@@ -21,85 +21,76 @@
 
 using namespace STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("finally is a sender", "[adaptors][finally]") {
+  TEST_CASE("finally is a sender", "[adaptors][finally]")
+  {
     auto s = exec::finally(just(), just());
     STATIC_REQUIRE(sender<decltype(s)>);
   }
 
-  TEST_CASE("finally with pipe syntax is a sender", "[adaptors][finally]") {
+  TEST_CASE("finally with pipe syntax is a sender", "[adaptors][finally]")
+  {
     auto s = just() | exec::finally(just());
     STATIC_REQUIRE(sender<decltype(s)>);
   }
 
-  TEST_CASE("finally is a sender in empty env", "[adaptors][finally]") {
+  TEST_CASE("finally is a sender in empty env", "[adaptors][finally]")
+  {
     auto s = exec::finally(just(), just());
     STATIC_REQUIRE(sender_in<decltype(s), ex::env<>>);
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_value_t()>
-      >);
+    STATIC_REQUIRE(set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                                  completion_signatures<set_value_t()>>);
   }
 
-  TEST_CASE("finally executes the final action", "[adaptors][finally]") {
+  TEST_CASE("finally executes the final action", "[adaptors][finally]")
+  {
     bool called = false;
-    auto s = exec::finally(just(), just() | then([&called]() noexcept { called = true; }));
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_value_t()>
-      >);
+    auto s      = exec::finally(just(), just() | then([&called]() noexcept { called = true; }));
+    STATIC_REQUIRE(set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                                  completion_signatures<set_value_t()>>);
     sync_wait(s);
     CHECK(called);
   }
 
-  TEST_CASE("finally executes the final action and returns integer", "[adaptors][finally]") {
+  TEST_CASE("finally executes the final action and returns integer", "[adaptors][finally]")
+  {
     bool called = false;
-    auto s = exec::finally(just(42), just() | then([&called]() noexcept { called = true; }));
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_value_t(int)>
-      >);
+    auto s      = exec::finally(just(42), just() | then([&called]() noexcept { called = true; }));
+    STATIC_REQUIRE(set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                                  completion_signatures<set_value_t(int)>>);
     auto [i] = *sync_wait(s);
     CHECK(called);
     CHECK(i == 42);
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("finally does not execute the final action and throws integer", "[adaptors][finally]") {
+  TEST_CASE("finally does not execute the final action and throws integer", "[adaptors][finally]")
+  {
     bool called = false;
 
-    auto s = exec::finally(
-      just(21) | then([](int) -> int { throw 42; }),
-      just() | then([&called]() noexcept(false) { called = true; }));
+    auto s = exec::finally(just(21) | then([](int) -> int { throw 42; }),
+                           just() | then([&called]() noexcept(false) { called = true; }));
     STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_error_t(std::exception_ptr), set_value_t(int)>
-      >);
+      set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                     completion_signatures<set_error_t(std::exception_ptr), set_value_t(int)>>);
     CHECK_THROWS_AS(sync_wait(s), int);
     CHECK(called);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("finally includes the error types of the final action", "[adaptors][finally]") {
+  TEST_CASE("finally includes the error types of the final action", "[adaptors][finally]")
+  {
     auto s = exec::finally(just(), just_error(42));
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_error_t(int)>
-      >);
+    STATIC_REQUIRE(set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                                  completion_signatures<set_error_t(int)>>);
   }
 
-  TEST_CASE("finally includes the stopped signal of the final action", "[adaptors][finally]") {
+  TEST_CASE("finally includes the stopped signal of the final action", "[adaptors][finally]")
+  {
     auto s = exec::finally(just(), just_stopped());
-    STATIC_REQUIRE(
-      set_equivalent<
-        completion_signatures_of_t<decltype(s), ex::env<>>,
-        completion_signatures<set_stopped_t()>
-      >);
+    STATIC_REQUIRE(set_equivalent<completion_signatures_of_t<decltype(s), ex::env<>>,
+                                  completion_signatures<set_stopped_t()>>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_into_variant.cpp b/test/stdexec/algos/adaptors/test_into_variant.cpp
index abfdb07f7..57960f0cf 100644
--- a/test/stdexec/algos/adaptors/test_into_variant.cpp
+++ b/test/stdexec/algos/adaptors/test_into_variant.cpp
@@ -24,94 +24,105 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("into_variant returns a sender", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant returns a sender", "[adaptors][into_variant]")
+  {
     auto snd = ex::into_variant(ex::just(11));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("into_variant with environment returns a sender", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant with environment returns a sender", "[adaptors][into_variant]")
+  {
     auto snd = ex::into_variant(ex::just(11));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("into_variant simple example", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant simple example", "[adaptors][into_variant]")
+  {
     bool called{false};
-    auto snd = ex::into_variant(ex::just(11)) | ex::then([&](std::variant<std::tuple<int>> x) {
-                 called = true;
-                 CHECK(std::get<0>(std::get<0>(x)) == 11);
-               });
+    auto snd = ex::into_variant(ex::just(11))
+             | ex::then(
+                 [&](std::variant<std::tuple<int>> x)
+                 {
+                   called = true;
+                   CHECK(std::get<0>(std::get<0>(x)) == 11);
+                 });
     auto op = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     CHECK(called);
   }
 
-  TEST_CASE("into_variant returning void can we waited on", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant returning void can we waited on", "[adaptors][into_variant]")
+  {
     ex::sender auto snd = ex::just(11) | ex::into_variant();
     wait_for_value(std::move(snd), std::variant<std::tuple<int>>{11});
   }
 
-  TEST_CASE(
-    "into_variant with senders that sends multiple values at once",
-    "[adaptors][into_variant]") {
+  TEST_CASE("into_variant with senders that sends multiple values at once",
+            "[adaptors][into_variant]")
+  {
     ex::sender auto snd = ex::just(3, 0.1415) | ex::into_variant();
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int, double>>{std::make_tuple(3, 0.1415)});
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int, double>>{std::make_tuple(3, 0.1415)});
   }
 
-  TEST_CASE(
-    "into_variant with senders that have multiple alternatives",
-    "[adaptors][into_variant]") {
-    ex::sender auto in_snd = fallible_just{13} | ex::let_error([](std::exception_ptr) {
-                               return ex::just(std::string{"err"});
-                             });
+  TEST_CASE("into_variant with senders that have multiple alternatives", "[adaptors][into_variant]")
+  {
+    ex::sender auto in_snd = fallible_just{13}
+                           | ex::let_error([](std::exception_ptr)
+                                           { return ex::just(std::string{"err"}); });
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(in_snd));
 
     ex::sender auto snd = std::move(in_snd) | ex::into_variant();
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int>, std::tuple<std::string>>{std::make_tuple(13)});
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int>, std::tuple<std::string>>{std::make_tuple(13)});
   }
 
-  TEST_CASE("into_variant can be used with just_error", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant can be used with just_error", "[adaptors][into_variant]")
+  {
     ex::sender auto snd = ex::just_error(std::string{"err"}) | ex::into_variant();
-    auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"err"}});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{std::string{"err"}});
     ex::start(op);
   }
 
-  TEST_CASE("into_variant can be used with just_stopped", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant can be used with just_stopped", "[adaptors][into_variant]")
+  {
     ex::sender auto snd = ex::just_stopped() | ex::into_variant();
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("into_variant forwards errors", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant forwards errors", "[adaptors][into_variant]")
+  {
     error_scheduler sched;
     ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::into_variant();
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("into_variant forwards cancellation", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant forwards cancellation", "[adaptors][into_variant]")
+  {
     stopped_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::into_variant();
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    ex::sender auto   snd = ex::just(13) | ex::continues_on(sched) | ex::into_variant();
+    auto              op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE(
-    "into_variant has the values_type corresponding to the given values",
-    "[adaptors][into_variant]") {
+  TEST_CASE("into_variant has the values_type corresponding to the given values",
+            "[adaptors][into_variant]")
+  {
     check_val_types<ex::__mset<pack<std::variant<std::tuple<>>>>>(ex::just() | ex::into_variant());
-    check_val_types<ex::__mset<pack<std::variant<std::tuple<int>>>>>(
-      ex::just(23) | ex::into_variant());
-    check_val_types<ex::__mset<pack<std::variant<std::tuple<double>>>>>(
-      ex::just(std::numbers::pi) | ex::into_variant());
+    check_val_types<ex::__mset<pack<std::variant<std::tuple<int>>>>>(ex::just(23)
+                                                                     | ex::into_variant());
+    check_val_types<ex::__mset<pack<std::variant<std::tuple<double>>>>>(ex::just(std::numbers::pi)
+                                                                        | ex::into_variant());
 
-    check_val_types<ex::__mset<pack<std::variant<std::tuple<int, double>>>>>(
-      ex::just(3, 0.1415) | ex::into_variant());
+    check_val_types<ex::__mset<pack<std::variant<std::tuple<int, double>>>>>(ex::just(3, 0.1415)
+                                                                             | ex::into_variant());
 
     check_val_types<ex::__mset<pack<std::variant<std::tuple<int>, std::tuple<std::string>>>>>(
       fallible_just{13}
@@ -120,24 +131,26 @@ namespace {
       | ex::into_variant());
   }
 
-  TEST_CASE("into_variant keeps error_types from input sender", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant keeps error_types from input sender", "[adaptors][into_variant]")
+  {
     inline_scheduler sched1{};
-    error_scheduler sched2{};
+    error_scheduler  sched2{};
 
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched1) | ex::into_variant());
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::into_variant());
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched1)
+                                                    | ex::into_variant());
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched2)
+                                                    | ex::into_variant());
     check_err_types<ex::__mset<std::exception_ptr, int>>(ex::just_error(-1) | ex::into_variant());
   }
 
-  TEST_CASE("into_variant keeps sends_stopped from input sender", "[adaptors][into_variant]") {
+  TEST_CASE("into_variant keeps sends_stopped from input sender", "[adaptors][into_variant]")
+  {
     inline_scheduler sched1{};
-    error_scheduler sched2{};
+    error_scheduler  sched2{};
 
     check_sends_stopped<false>(ex::just() | ex::continues_on(sched1) | ex::into_variant());
     check_sends_stopped<true>(ex::just() | ex::continues_on(sched2) | ex::into_variant());
     check_sends_stopped<true>(ex::just_stopped() | ex::into_variant());
   }
 
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_let_error.cpp b/test/stdexec/algos/adaptors/test_let_error.cpp
index e01cc8bc4..a50d5bae2 100644
--- a/test/stdexec/algos/adaptors/test_let_error.cpp
+++ b/test/stdexec/algos/adaptors/test_let_error.cpp
@@ -25,76 +25,88 @@
 #include <test_common/senders.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono> // IWYU pragma: keep for chrono_literals
+#include <chrono>  // IWYU pragma: keep for chrono_literals
 
 namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("let_error returns a sender", "[adaptors][let_error]") {
+  TEST_CASE("let_error returns a sender", "[adaptors][let_error]")
+  {
     auto snd = ex::let_error(ex::just(), [](std::exception_ptr) { return ex::just(); });
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("let_error with environment returns a sender", "[adaptors][let_error]") {
+  TEST_CASE("let_error with environment returns a sender", "[adaptors][let_error]")
+  {
     auto snd = ex::let_error(ex::just(), [](std::exception_ptr) { return ex::just(); });
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("let_error simple example", "[adaptors][let_error]") {
+  TEST_CASE("let_error simple example", "[adaptors][let_error]")
+  {
     bool called{false};
-    auto snd = ex::let_error(ex::just_error(std::exception_ptr{}), [&](std::exception_ptr) {
-      called = true;
-      return ex::just();
-    });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto snd = ex::let_error(ex::just_error(std::exception_ptr{}),
+                             [&](std::exception_ptr)
+                             {
+                               called = true;
+                               return ex::just();
+                             });
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("let_error simple example reference", "[adaptors][let_error]") {
+  TEST_CASE("let_error simple example reference", "[adaptors][let_error]")
+  {
     bool called{false};
-    auto snd =
-      ex::let_error(exec::split(ex::just_error(std::exception_ptr{})), [&](std::exception_ptr) {
-        called = true;
-        return ex::just();
-      });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto snd = ex::let_error(exec::split(ex::just_error(std::exception_ptr{})),
+                             [&](std::exception_ptr)
+                             {
+                               called = true;
+                               return ex::just();
+                             });
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("let_error can be piped", "[adaptors][let_error]") {
+  TEST_CASE("let_error can be piped", "[adaptors][let_error]")
+  {
     ex::sender auto snd = ex::just() | ex::let_error([](std::exception_ptr) { return ex::just(); });
     (void) snd;
   }
 
-  TEST_CASE(
-    "let_error returning void can be waited on (error annihilation)",
-    "[adaptors][let_error]") {
+  TEST_CASE("let_error returning void can be waited on (error annihilation)",
+            "[adaptors][let_error]")
+  {
     ex::sender auto snd = ex::just_error(std::exception_ptr{})
                         | ex::let_error([](std::exception_ptr) { return ex::just(); });
     STDEXEC::sync_wait(std::move(snd));
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("let_error can be used to produce values (error to value)", "[adaptors][let_error]") {
+  TEST_CASE("let_error can be used to produce values (error to value)", "[adaptors][let_error]")
+  {
     ex::sender auto snd = ex::just() | ex::then([]() -> std::string {
       throw std::logic_error{"error description"};
                           })
                         | ex::let_error([](std::exception_ptr eptr) {
-      STDEXEC_TRY {
+      STDEXEC_TRY
+      {
         std::rethrow_exception(eptr);
       }
-      STDEXEC_CATCH(const std::exception& e) {
+      STDEXEC_CATCH(std::exception const & e)
+      {
         return ex::just(std::string{e.what()});
       }
     STDEXEC_CATCH_FALLTHROUGH
diff --git a/test/stdexec/algos/adaptors/test_let_fail1.cpp b/test/stdexec/algos/adaptors/test_let_fail1.cpp
index a982653ad..65b37c180 100644
--- a/test/stdexec/algos/adaptors/test_let_fail1.cpp
+++ b/test/stdexec/algos/adaptors/test_let_fail1.cpp
@@ -18,8 +18,9 @@
 
 namespace ex = STDEXEC;
 
-auto main() -> int {
-  ex::sender auto snd = ex::just(42) | ex::let_value([](int) { });
+auto main() -> int
+{
+  ex::sender auto snd = ex::just(42) | ex::let_value([](int) {});
   // build error: _FUNCTION_MUST_RETURN_A_VALID_SENDER_IN_THE_CURRENT_ENVIRONMENT_
   STDEXEC::sync_wait(std::move(snd));
 }
diff --git a/test/stdexec/algos/adaptors/test_let_stopped.cpp b/test/stdexec/algos/adaptors/test_let_stopped.cpp
index 0492a5685..9326279e9 100644
--- a/test/stdexec/algos/adaptors/test_let_stopped.cpp
+++ b/test/stdexec/algos/adaptors/test_let_stopped.cpp
@@ -22,134 +22,152 @@
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono> // IWYU pragma: keep for chrono_literals
+#include <chrono>  // IWYU pragma: keep for chrono_literals
 
 namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("let_stopped returns a sender", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped returns a sender", "[adaptors][let_stopped]")
+  {
     auto snd = ex::let_stopped(ex::just(), [] { return ex::just(); });
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("let_stopped with environment returns a sender", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped with environment returns a sender", "[adaptors][let_stopped]")
+  {
     auto snd = ex::let_stopped(ex::just(), [] { return ex::just(); });
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("let_stopped simple example", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped simple example", "[adaptors][let_stopped]")
+  {
     bool called{false};
-    auto snd = ex::let_stopped(ex::just_stopped(), [&] {
-      called = true;
-      return ex::just();
-    });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto snd = ex::let_stopped(ex::just_stopped(),
+                               [&]
+                               {
+                                 called = true;
+                                 return ex::just();
+                               });
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("let_stopped can be piped", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can be piped", "[adaptors][let_stopped]")
+  {
     ex::sender auto snd = ex::just() | ex::let_stopped([] { return ex::just(); });
     (void) snd;
   }
 
-  TEST_CASE(
-    "let_stopped returning void can we waited on (cancel annihilation)",
-    "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped returning void can we waited on (cancel annihilation)",
+            "[adaptors][let_stopped]")
+  {
     ex::sender auto snd = ex::just_stopped() | ex::let_stopped([] { return ex::just(); });
     STDEXEC::sync_wait(std::move(snd));
   }
 
-  TEST_CASE(
-    "let_stopped can be used to produce values (cancel to value)",
-    "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can be used to produce values (cancel to value)",
+            "[adaptors][let_stopped]")
+  {
     ex::sender auto snd = ex::just_stopped()
                         | ex::let_stopped([] { return ex::just(std::string{"cancelled"}); });
     wait_for_value(std::move(snd), std::string{"cancelled"});
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("let_stopped can throw, calling set_error", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can throw, calling set_error", "[adaptors][let_stopped]")
+  {
     auto snd = ex::just_stopped()
              | ex::let_stopped([]() -> decltype(ex::just(0)) { throw std::logic_error{"err"}; });
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("let_stopped can be used with just_error", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can be used with just_error", "[adaptors][let_stopped]")
+  {
     ex::sender auto snd = ex::just_error(1) | ex::let_stopped([] { return ex::just(17); });
-    auto op = ex::connect(std::move(snd), expect_error_receiver{1});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{1});
     ex::start(op);
   }
 
-  TEST_CASE("let_stopped function is not called on regular flow", "[adaptors][let_stopped]") {
-    bool called{false};
+  TEST_CASE("let_stopped function is not called on regular flow", "[adaptors][let_stopped]")
+  {
+    bool            called{false};
     error_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::let_stopped([&] {
-                            called = true;
-                            return ex::just(0);
-                          });
+    ex::sender auto snd = ex::just(13)
+                        | ex::let_stopped(
+                            [&]
+                            {
+                              called = true;
+                              return ex::just(0);
+                            });
     auto op = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE("let_stopped function is not called on error flow", "[adaptors][let_stopped]") {
-    bool called{false};
+  TEST_CASE("let_stopped function is not called on error flow", "[adaptors][let_stopped]")
+  {
+    bool                 called{false};
     error_scheduler<int> sched{42};
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::let_stopped([&] {
-                            called = true;
-                            return ex::just(0);
-                          });
+    ex::sender auto      snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::let_stopped(
+                            [&]
+                            {
+                              called = true;
+                              return ex::just(0);
+                            });
     auto op = ex::connect(std::move(snd), expect_error_receiver{42});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE(
-    "let_stopped has the values_type from the input sender if returning error",
-    "[adaptors][let_stopped]") {
-    check_val_types<ex::__mset<pack<int>>>(
-      ex::just(7) | ex::let_stopped([] { return ex::just_error(0); }));
-    check_val_types<ex::__mset<pack<double>>>(
-      ex::just(3.14) | ex::let_stopped([] { return ex::just_error(0); }));
+  TEST_CASE("let_stopped has the values_type from the input sender if returning error",
+            "[adaptors][let_stopped]")
+  {
+    check_val_types<ex::__mset<pack<int>>>(ex::just(7)
+                                           | ex::let_stopped([] { return ex::just_error(0); }));
+    check_val_types<ex::__mset<pack<double>>>(ex::just(3.14)
+                                              | ex::let_stopped([] { return ex::just_error(0); }));
     check_val_types<ex::__mset<pack<std::string>>>(
       ex::just(std::string{"hello"}) | ex::let_stopped([] { return ex::just_error(0); }));
   }
 
-  TEST_CASE(
-    "let_stopped adds to values_type the value types of the returned sender",
-    "[adaptors][let_stopped]") {
-    check_val_types<ex::__mset<pack<int>>>(
-      ex::just(1) | ex::let_stopped([] { return ex::just(11); }));
-    check_val_types<ex::__mset<pack<int>>>(
-      ex::just(1) | ex::let_stopped([] { return ex::just(3.14); }));
+  TEST_CASE("let_stopped adds to values_type the value types of the returned sender",
+            "[adaptors][let_stopped]")
+  {
+    check_val_types<ex::__mset<pack<int>>>(ex::just(1)
+                                           | ex::let_stopped([] { return ex::just(11); }));
+    check_val_types<ex::__mset<pack<int>>>(ex::just(1)
+                                           | ex::let_stopped([] { return ex::just(3.14); }));
     check_val_types<ex::__mset<pack<int>>>(
       ex::just(1) | ex::let_stopped([] { return ex::just(std::string{"hello"}); }));
   }
 
-  TEST_CASE(
-    "let_stopped has the error_type from the input sender if returning value",
-    "[adaptors][let_stopped]") {
-    check_err_types<ex::__mset<int>>(
-      ex::just_error(7) | ex::let_stopped([] { return ex::just(0); }));
-    check_err_types<ex::__mset<double>>(
-      ex::just_error(3.14) | ex::let_stopped([] { return ex::just(0); }));
-    check_err_types<ex::__mset<std::string>>(
-      ex::just_error(std::string{"hello"}) | ex::let_stopped([] { return ex::just(0); }));
+  TEST_CASE("let_stopped has the error_type from the input sender if returning value",
+            "[adaptors][let_stopped]")
+  {
+    check_err_types<ex::__mset<int>>(ex::just_error(7)
+                                     | ex::let_stopped([] { return ex::just(0); }));
+    check_err_types<ex::__mset<double>>(ex::just_error(3.14)
+                                        | ex::let_stopped([] { return ex::just(0); }));
+    check_err_types<ex::__mset<std::string>>(ex::just_error(std::string{"hello"})
+                                             | ex::let_stopped([] { return ex::just(0); }));
   }
 
-  TEST_CASE("let_stopped adds to error_type of the input sender", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped adds to error_type of the input sender", "[adaptors][let_stopped]")
+  {
     impulse_scheduler sched;
-    ex::sender auto in_snd = ex::just(11) | ex::continues_on(sched);
+    ex::sender auto   in_snd = ex::just(11) | ex::continues_on(sched);
     check_err_types<ex::__mset<std::exception_ptr, int>>(
       in_snd | ex::let_stopped([] { return ex::just_error(0); }));
     check_err_types<ex::__mset<std::exception_ptr, double>>(
@@ -158,9 +176,10 @@ namespace {
       in_snd | ex::let_stopped([] { return ex::just_error(std::string{"err"}); }));
   }
 
-  TEST_CASE("let_stopped can be used instead of stopped_as_error", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can be used instead of stopped_as_error", "[adaptors][let_stopped]")
+  {
     impulse_scheduler sched;
-    ex::sender auto in_snd = ex::just(11) | ex::continues_on(sched);
+    ex::sender auto   in_snd = ex::just(11) | ex::continues_on(sched);
     check_val_types<ex::__mset<pack<int>>>(in_snd);
     check_err_types<ex::__mset<>>(in_snd);
     check_sends_stopped<true>(in_snd);
@@ -172,37 +191,41 @@ namespace {
     check_sends_stopped<false>(snd);
   }
 
-  TEST_CASE("let_stopped overrides sends_stopped from input sender", "[adaptors][let_stopped]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("let_stopped overrides sends_stopped from input sender", "[adaptors][let_stopped]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     // Returning ex::just
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched1) | ex::let_stopped([] { return ex::just(); }));
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched2) | ex::let_stopped([] { return ex::just(); }));
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched3) | ex::let_stopped([] { return ex::just(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1)
+                               | ex::let_stopped([] { return ex::just(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched2)
+                               | ex::let_stopped([] { return ex::just(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched3)
+                               | ex::let_stopped([] { return ex::just(); }));
 
     // Returning ex::just_stopped
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched1) | ex::let_stopped([] { return ex::just_stopped(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched2) | ex::let_stopped([] { return ex::just_stopped(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched3) | ex::let_stopped([] { return ex::just_stopped(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1)
+                               | ex::let_stopped([] { return ex::just_stopped(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched2)
+                              | ex::let_stopped([] { return ex::just_stopped(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched3)
+                              | ex::let_stopped([] { return ex::just_stopped(); }));
   }
 
   // Return a different sender when we invoke this custom defined let_stopped implementation
-  struct let_stopped_test_domain {
+  struct let_stopped_test_domain
+  {
     template <ex::sender_expr_for<ex::let_stopped_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...)
+    {
       return ex::just(std::string{"Don't stop me now"});
     }
   };
 
-  TEST_CASE("let_stopped can be customized", "[adaptors][let_stopped]") {
+  TEST_CASE("let_stopped can be customized", "[adaptors][let_stopped]")
+  {
     basic_inline_scheduler<let_stopped_test_domain> sched;
 
     // The customization will return a different stopped
@@ -210,4 +233,4 @@ namespace {
              | ex::let_stopped([] { return ex::just(std::string{"stopped"}); });
     wait_for_value(std::move(snd), std::string{"Don't stop me now"});
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_let_value.cpp b/test/stdexec/algos/adaptors/test_let_value.cpp
index 466e93e57..0d9a00c4a 100644
--- a/test/stdexec/algos/adaptors/test_let_value.cpp
+++ b/test/stdexec/algos/adaptors/test_let_value.cpp
@@ -24,7 +24,7 @@
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono> // IWYU pragma: keep for chrono_literals
+#include <chrono>  // IWYU pragma: keep for chrono_literals
 #include <exception>
 #include <memory>
 
@@ -32,71 +32,85 @@ namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("let_value returns a sender", "[adaptors][let_value]") {
+  TEST_CASE("let_value returns a sender", "[adaptors][let_value]")
+  {
     auto snd = ex::let_value(ex::just(), [] { return ex::just(); });
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("let_value with environment returns a sender", "[adaptors][let_value]") {
+  TEST_CASE("let_value with environment returns a sender", "[adaptors][let_value]")
+  {
     auto snd = ex::let_value(ex::just(), [] { return ex::just(); });
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("let_value simple example", "[adaptors][let_value]") {
+  TEST_CASE("let_value simple example", "[adaptors][let_value]")
+  {
     bool called{false};
-    auto snd = ex::let_value(ex::just(), [&] {
-      called = true;
-      return ex::just();
-    });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto snd = ex::let_value(ex::just(),
+                             [&]
+                             {
+                               called = true;
+                               return ex::just();
+                             });
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("let_value can be piped", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be piped", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just() | ex::let_value([] { return ex::just(); });
     (void) snd;
   }
 
-  TEST_CASE("let_value returning void can we waited on", "[adaptors][let_value]") {
+  TEST_CASE("let_value returning void can we waited on", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just() | ex::let_value([] { return ex::just(); });
     STDEXEC::sync_wait(std::move(snd));
   }
 
-  TEST_CASE("let_value can be used to produce values", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used to produce values", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just() | ex::let_value([] { return ex::just(13); });
     wait_for_value(std::move(snd), 13);
   }
 
-  TEST_CASE("let_value can be used to transform values", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used to transform values", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just(13) | ex::let_value([](int& x) { return ex::just(x + 4); });
     wait_for_value(std::move(snd), 17);
   }
 
-  TEST_CASE("let_value can be used with multiple parameters", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used with multiple parameters", "[adaptors][let_value]")
+  {
     auto snd = ex::just(3, 0.1415)
              | ex::let_value([](int& x, double y) { return ex::just(x + y); });
-    wait_for_value(std::move(snd), 3.1415); // NOLINT(modernize-use-std-numbers)
+    wait_for_value(std::move(snd), 3.1415);  // NOLINT(modernize-use-std-numbers)
   }
 
-  TEST_CASE("let_value can be used to change the sender", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used to change the sender", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just(13)
                         | ex::let_value([](int& x) { return ex::just_error(x + 4); });
     auto op = ex::connect(std::move(snd), expect_error_receiver{13 + 4});
     ex::start(op);
   }
 
-  auto is_prime(int x) -> bool {
+  auto is_prime(int x) -> bool
+  {
     if (x > 2 && (x % 2 == 0))
       return false;
     int d = 3;
-    while (d * d < x) {
+    while (d * d < x)
+    {
       if (x % d == 0)
         return false;
       d += 2;
@@ -105,19 +119,23 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("let_value can be used for composition", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used for composition", "[adaptors][let_value]")
+  {
     bool called1{false};
     bool called2{false};
     bool called3{false};
-    auto f1 = [&](int& x) {
+    auto f1 = [&](int& x)
+    {
       called1 = true;
       return ex::just(2 * x);
     };
-    auto f2 = [&](int& x) {
+    auto f2 = [&](int& x)
+    {
       called2 = true;
       return ex::just(x + 3);
     };
-    auto f3 = [&](int& x) {
+    auto f3 = [&](int& x)
+    {
       called3 = true;
       if (!is_prime(x))
         throw std::logic_error("not prime");
@@ -130,108 +148,126 @@ namespace {
     CHECK(called3);
   }
 
-  TEST_CASE("let_value can throw, and set_error will be called", "[adaptors][let_value]") {
-    struct invocable {
-      decltype(ex::just(0)) operator()(int&) && {
+  TEST_CASE("let_value can throw, and set_error will be called", "[adaptors][let_value]")
+  {
+    struct invocable
+    {
+      decltype(ex::just(0)) operator()(int&) &&
+      {
         throw std::logic_error{"err"};
       }
-      auto operator()(int&&) && noexcept {
+      auto operator()(int&&) && noexcept
+      {
         return ex::just();
       }
     };
     auto snd = ex::just(13) | ex::let_value(invocable{});
-    static_assert(set_equivalent<
-                  ::STDEXEC::completion_signatures<
-                    ::STDEXEC::set_value_t(int),
-                    ::STDEXEC::set_error_t(std::exception_ptr)
-                  >,
-                  ::STDEXEC::completion_signatures_of_t<decltype(snd), ::STDEXEC::env<>>
-    >);
+    static_assert(
+      set_equivalent<::STDEXEC::completion_signatures<::STDEXEC::set_value_t(int),
+                                                      ::STDEXEC::set_error_t(std::exception_ptr)>,
+                     ::STDEXEC::completion_signatures_of_t<decltype(snd), ::STDEXEC::env<>>>);
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("let_value can be used with just_error", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used with just_error", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just_error(std::string{"err"})
                         | ex::let_value([]() { return ex::just(17); });
     auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"err"}});
     ex::start(op);
   }
 
-  TEST_CASE("let_value can be used with just_stopped", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be used with just_stopped", "[adaptors][let_value]")
+  {
     ex::sender auto snd = ex::just_stopped() | ex::let_value([]() { return ex::just(17); });
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("let_value function is not called on error", "[adaptors][let_value]") {
-    bool called{false};
+  TEST_CASE("let_value function is not called on error", "[adaptors][let_value]")
+  {
+    bool            called{false};
     error_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::let_value([&](int& x) {
-                            called = true;
-                            return ex::just(x + 5);
-                          });
+    ex::sender auto snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::let_value(
+                            [&](int& x)
+                            {
+                              called = true;
+                              return ex::just(x + 5);
+                            });
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE("let_value function is not called when cancelled", "[adaptors][let_value]") {
-    bool called{false};
+  TEST_CASE("let_value function is not called when cancelled", "[adaptors][let_value]")
+  {
+    bool              called{false};
     stopped_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::let_value([&](int& x) {
-                            called = true;
-                            return ex::just(x + 5);
-                          });
+    ex::sender auto   snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::let_value(
+                            [&](int& x)
+                            {
+                              called = true;
+                              return ex::just(x + 5);
+                            });
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE(
-    "let_value exposes a parameter that is destructed when the main operation is destructed",
-    "[adaptors][let_value]") {
-
+  TEST_CASE("let_value exposes a parameter that is destructed when the main operation is "
+            "destructed",
+            "[adaptors][let_value]")
+  {
     // Type that sets into a received boolean when the dtor is called
-    struct my_type {
+    struct my_type
+    {
       bool* p_called_{nullptr};
 
       explicit my_type(bool* p_called)
-        : p_called_(p_called) {
-      }
+        : p_called_(p_called)
+      {}
 
       my_type(my_type&& rhs)
-        : p_called_(rhs.p_called_) {
+        : p_called_(rhs.p_called_)
+      {
         rhs.p_called_ = nullptr;
       }
 
-      auto operator=(my_type&& rhs) -> my_type& {
+      auto operator=(my_type&& rhs) -> my_type&
+      {
         if (p_called_)
           *p_called_ = true;
-        p_called_ = rhs.p_called_;
+        p_called_     = rhs.p_called_;
         rhs.p_called_ = nullptr;
         return *this;
       }
 
-      ~my_type() {
+      ~my_type()
+      {
         if (p_called_)
           *p_called_ = true;
       }
     };
 
-    bool param_destructed{false};
-    bool fun_called{false};
+    bool              param_destructed{false};
+    bool              fun_called{false};
     impulse_scheduler sched;
 
-    ex::sender auto snd = ex::just(my_type(&param_destructed)) | ex::let_value([&](const my_type&) {
-                            CHECK_FALSE(param_destructed);
-                            fun_called = true;
-                            return ex::just(13) | ex::continues_on(sched);
-                          });
+    ex::sender auto snd = ex::just(my_type(&param_destructed))
+                        | ex::let_value(
+                            [&](my_type const &)
+                            {
+                              CHECK_FALSE(param_destructed);
+                              fun_called = true;
+                              return ex::just(13) | ex::continues_on(sched);
+                            });
 
     {
-      int res{0};
+      int  res{0};
       auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
       ex::start(op);
       // The function is called immediately after starting the operation
@@ -252,17 +288,20 @@ namespace {
     CHECK(param_destructed);
   }
 
-  TEST_CASE("let_value works when changing threads", "[adaptors][let_value]") {
+  TEST_CASE("let_value works when changing threads", "[adaptors][let_value]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // lunch some work on the thread pool
       ex::sender auto snd = ex::just(7) | ex::continues_on(pool.get_scheduler())
                           | ex::let_value([](int& x) { return ex::just(x * 2 - 1); })
-                          | ex::then([&](int x) {
-                              CHECK(x == 13);
-                              called.store(true);
-                            });
+                          | ex::then(
+                              [&](int x)
+                              {
+                                CHECK(x == 13);
+                                called.store(true);
+                              });
       exec::start_detached(std::move(snd));
     }
     // wait for the work to be executed, with timeout
@@ -274,58 +313,63 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE(
-    "let_value has the values_type corresponding to the given values",
-    "[adaptors][let_value]") {
+  TEST_CASE("let_value has the values_type corresponding to the given values",
+            "[adaptors][let_value]")
+  {
     check_val_types<ex::__mset<pack<int>>>(ex::just() | ex::let_value([] { return ex::just(7); }));
-    check_val_types<ex::__mset<pack<double>>>(
-      ex::just() | ex::let_value([] { return ex::just(3.14); }));
+    check_val_types<ex::__mset<pack<double>>>(ex::just()
+                                              | ex::let_value([] { return ex::just(3.14); }));
     check_val_types<ex::__mset<pack<std::string>>>(
       ex::just() | ex::let_value([] { return ex::just(std::string{"hello"}); }));
   }
 
-  TEST_CASE("let_value keeps error_types from input sender", "[adaptors][let_value]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("let_value keeps error_types from input sender", "[adaptors][let_value]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched1) | ex::let_value([] { return ex::just(); }));
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::let_value([] { return ex::just(); }));
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched1)
+                                                    | ex::let_value([] { return ex::just(); }));
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched2)
+                                                    | ex::let_value([] { return ex::just(); }));
     check_err_types<ex::__mset<int, std::exception_ptr>>(
       ex::just() | ex::continues_on(sched3) | ex::let_value([] { return ex::just(); }));
 
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1) | ex::let_value([]() noexcept { return ex::just(); }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::let_value([]() noexcept { return ex::just(); }));
     check_err_types<ex::__mset<std::exception_ptr>>(
       ex::just() | ex::continues_on(sched2) | ex::let_value([]() noexcept { return ex::just(); }));
-    check_err_types<ex::__mset<int>>(
-      ex::just() | ex::continues_on(sched3) | ex::let_value([]() noexcept { return ex::just(); }));
+    check_err_types<ex::__mset<int>>(ex::just() | ex::continues_on(sched3)
+                                     | ex::let_value([]() noexcept { return ex::just(); }));
   }
 
-  TEST_CASE("let_value keeps sends_stopped from input sender", "[adaptors][let_value]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("let_value keeps sends_stopped from input sender", "[adaptors][let_value]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
-    check_sends_stopped<false>(
-      ex::just() | ex::continues_on(sched1) | ex::let_value([] { return ex::just(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched2) | ex::let_value([] { return ex::just(); }));
-    check_sends_stopped<true>(
-      ex::just() | ex::continues_on(sched3) | ex::let_value([] { return ex::just(); }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1)
+                               | ex::let_value([] { return ex::just(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched2)
+                              | ex::let_value([] { return ex::just(); }));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched3)
+                              | ex::let_value([] { return ex::just(); }));
   }
 
   // Return a different sender when we invoke this custom defined let_value implementation
-  struct let_value_test_domain {
+  struct let_value_test_domain
+  {
     template <ex::sender_expr_for<ex::let_value_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto&&...)
+    {
       return ex::just(std::string{"hallo"});
     }
   };
 
-  TEST_CASE("let_value can be customized", "[adaptors][let_value]") {
+  TEST_CASE("let_value can be customized", "[adaptors][let_value]")
+  {
     basic_inline_scheduler<let_value_test_domain> sched;
 
     // The customization will return a different value
@@ -334,87 +378,99 @@ namespace {
     wait_for_value(std::move(snd), std::string{"hallo"});
   }
 
-  TEST_CASE("let_value can nest", "[adaptors][let_value]") {
-    auto work = ex::just(2) | ex::let_value([](int x) {
-                  return ex::just() | ex::let_value([=] { return ex::just(x); });
-                });
+  TEST_CASE("let_value can nest", "[adaptors][let_value]")
+  {
+    auto work = ex::just(2)
+              | ex::let_value([](int x)
+                              { return ex::just() | ex::let_value([=] { return ex::just(x); }); });
     wait_for_value(std::move(work), 2);
   }
 
-  struct bad_receiver {
+  struct bad_receiver
+  {
     using receiver_concept = ex::receiver_t;
 
     bad_receiver(bool& completed) noexcept
-      : completed_{completed} {
-    }
+      : completed_{completed}
+    {}
 
-    void set_value() noexcept {
+    void set_value() noexcept
+    {
       completed_ = true;
     }
 
     bool& completed_;
   };
 
-  TEST_CASE(
-    "let_value does not add std::exception_ptr even if the receiver is bad",
-    "[adaptors][let_value]") {
+  TEST_CASE("let_value does not add std::exception_ptr even if the receiver is bad",
+            "[adaptors][let_value]")
+  {
     auto snd = ex::let_value(ex::just(), []() noexcept { return ex::just(); });
     check_err_types<ex::__mset<>>(snd);
     bool completed{false};
-    auto op = ex::connect(std::move(snd), bad_receiver{completed}); // should compile
+    auto op = ex::connect(std::move(snd), bad_receiver{completed});  // should compile
     ex::start(op);
     CHECK(completed);
   }
 
-  struct throws_on_connect {
+  struct throws_on_connect
+  {
     using sender_concept = ::STDEXEC::sender_t;
 
     template <class>
-    static consteval auto get_completion_signatures() noexcept {
+    static consteval auto get_completion_signatures() noexcept
+    {
       return ::STDEXEC::completion_signatures<::STDEXEC::set_value_t()>{};
     }
 
     template <class Receiver>
-    auto connect(Receiver) const
-      -> ::STDEXEC::connect_result_t<decltype(::STDEXEC::just()), Receiver> {
+    auto
+    connect(Receiver) const -> ::STDEXEC::connect_result_t<decltype(::STDEXEC::just()), Receiver>
+    {
       throw std::logic_error("TEST");
     }
   };
 
-  TEST_CASE(
-    "When connecting the successor throws an exception let_value delivers an error completion "
-    "signal to a valid receiver",
-    "[adaptors][let_value]") {
-    struct receiver {
+  TEST_CASE("When connecting the successor throws an exception let_value delivers an error "
+            "completion "
+            "signal to a valid receiver",
+            "[adaptors][let_value]")
+  {
+    struct receiver
+    {
       using receiver_concept = ::STDEXEC::receiver_t;
       std::shared_ptr<int> ptr;
-      void set_value() noexcept {
+      void                 set_value() noexcept
+      {
         FAIL_CHECK("Operation should end in error");
       }
-      void set_error(std::exception_ptr ex) noexcept {
+      void set_error(std::exception_ptr ex) noexcept
+      {
         CHECK(ex);
         REQUIRE(ptr);
         *ptr = 5;
       }
     };
-    const auto ptr = std::make_shared<int>(0);
+    auto const ptr = std::make_shared<int>(0);
     auto sender = ex::let_value(::STDEXEC::just(), []() noexcept { return throws_on_connect{}; });
-    auto op = ex::connect(std::move(sender), receiver{ptr});
+    auto op     = ex::connect(std::move(sender), receiver{ptr});
     ex::start(op);
     CHECK(*ptr == 5);
   }
 
-  TEST_CASE(
-    "let_value destroys the first operation state before invoking the sender factory",
-    "[adaptors][let_value]") {
-    const auto ptr = std::make_shared<int>(5);
+  TEST_CASE("let_value destroys the first operation state before invoking the sender factory",
+            "[adaptors][let_value]")
+  {
+    auto const ptr = std::make_shared<int>(5);
     CHECK(ptr.use_count() == 1);
-    auto first = ex::just() | ex::then([ptr = ptr]() { });
+    auto first = ex::just() | ex::then([ptr = ptr]() {});
     CHECK(ptr.use_count() == 2);
-    auto sender = ex::let_value(std::move(first), [&]() {
-      CHECK(ptr.use_count() == 2);
-      return ex::just();
-    });
+    auto sender = ex::let_value(std::move(first),
+                                [&]()
+                                {
+                                  CHECK(ptr.use_count() == 2);
+                                  return ex::just();
+                                });
     CHECK(ptr.use_count() == 2);
     auto op = ex::connect(std::move(sender), expect_void_receiver{});
     CHECK(ptr.use_count() == 2);
@@ -422,36 +478,41 @@ namespace {
     CHECK(ptr.use_count() == 1);
   }
 
-  struct immovable_sender {
+  struct immovable_sender
+  {
     using sender_concept = ::STDEXEC::sender_t;
 
     template <class, class... Env>
-    static consteval auto get_completion_signatures() noexcept {
+    static consteval auto get_completion_signatures() noexcept
+    {
       return ::STDEXEC::completion_signatures_of_t<decltype(::STDEXEC::just()), Env...>{};
     }
 
     template <class Receiver>
-    auto connect(Receiver r) const & noexcept {
+    auto connect(Receiver r) const & noexcept
+    {
       return ::STDEXEC::connect(::STDEXEC::just(), std::move(r));
     }
 
     immovable_sender() = default;
-    immovable_sender(const immovable_sender&) {
+    immovable_sender(immovable_sender const &)
+    {
       throw std::logic_error("Unexpected copy");
     }
   };
   static_assert(::STDEXEC::sender<immovable_sender>);
-  static_assert(::STDEXEC::sender<const immovable_sender&>);
+  static_assert(::STDEXEC::sender<immovable_sender const &>);
   static_assert(::STDEXEC::sender_in<immovable_sender, ::STDEXEC::env<>>);
-  static_assert(::STDEXEC::sender_in<const immovable_sender&, ::STDEXEC::env<>>);
-
-  TEST_CASE(
-    "If the sender factory returns a reference to a sender that reference is passed to connect",
-    "[adaptors][let_value]") {
-    const immovable_sender s;
-    auto just = ex::just();
-    auto sender = ex::let_value(just, [&]() -> decltype(auto) { return (s); });
-    auto op = ex::connect(sender, expect_void_receiver{});
+  static_assert(::STDEXEC::sender_in<immovable_sender const &, ::STDEXEC::env<>>);
+
+  TEST_CASE("If the sender factory returns a reference to a sender that reference is passed to "
+            "connect",
+            "[adaptors][let_value]")
+  {
+    immovable_sender const s;
+    auto                   just   = ex::just();
+    auto                   sender = ex::let_value(just, [&]() -> decltype(auto) { return (s); });
+    auto                   op     = ex::connect(sender, expect_void_receiver{});
     ex::start(op);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_on.cpp b/test/stdexec/algos/adaptors/test_on.cpp
index 232f79d88..a666bd6aa 100644
--- a/test/stdexec/algos/adaptors/test_on.cpp
+++ b/test/stdexec/algos/adaptors/test_on.cpp
@@ -23,46 +23,53 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   template <ex::scheduler Sched = inline_scheduler>
-  inline auto _with_scheduler(Sched sched = {}) {
+  inline auto _with_scheduler(Sched sched = {})
+  {
     return ex::write_env(ex::prop{ex::get_scheduler, std::move(sched)});
   }
 
   template <ex::scheduler Sched = inline_scheduler>
-  inline auto _make_env_with_sched(Sched sched = {}) {
+  inline auto _make_env_with_sched(Sched sched = {})
+  {
     return ex::prop{ex::get_scheduler, std::move(sched)};
   }
 
   using _env_with_sched_t = decltype(_make_env_with_sched());
 
-  TEST_CASE("STDEXEC::on returns a sender", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on returns a sender", "[adaptors][on]")
+  {
     auto snd = ex::on(inline_scheduler{}, ex::just(13));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("STDEXEC::on with environment returns a sender", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on with environment returns a sender", "[adaptors][on]")
+  {
     auto snd = ex::on(inline_scheduler{}, ex::just(13));
     static_assert(ex::sender_in<decltype(snd), _env_with_sched_t>);
     (void) snd;
   }
 
-  TEST_CASE("STDEXEC::on simple example", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on simple example", "[adaptors][on]")
+  {
     auto snd = ex::on(inline_scheduler{}, ex::just(13));
-    auto op =
-      ex::connect(std::move(snd), expect_value_receiver{env_tag{}, _make_env_with_sched(), 13});
+    auto op  = ex::connect(std::move(snd),
+                          expect_value_receiver{env_tag{}, _make_env_with_sched(), 13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("STDEXEC::on calls the receiver when the scheduler dictates", "[adaptors][on]") {
-    int recv_value{0};
+  TEST_CASE("STDEXEC::on calls the receiver when the scheduler dictates", "[adaptors][on]")
+  {
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto env = _make_env_with_sched();
-    auto snd = ex::on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{env, recv_value});
+    auto              env = _make_env_with_sched();
+    auto              snd = ex::on(sched, ex::just(13));
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{env, recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task; no effect expected
     CHECK(recv_value == 0);
@@ -72,18 +79,22 @@ namespace {
     CHECK(recv_value == 13);
   }
 
-  TEST_CASE("STDEXEC::on calls the given sender when the scheduler dictates", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on calls the given sender when the scheduler dictates", "[adaptors][on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::then([&]() -> int {
-                      called = true;
-                      return 19;
-                    });
-
-    int recv_value{0};
+    auto snd_base = ex::just()
+                  | ex::then(
+                      [&]() -> int
+                      {
+                        called = true;
+                        return 19;
+                      });
+
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto env = _make_env_with_sched();
-    auto snd = ex::on(sched, std::move(snd_base));
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{env, recv_value});
+    auto              env = _make_env_with_sched();
+    auto              snd = ex::on(sched, std::move(snd_base));
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{env, recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -97,9 +108,10 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE("STDEXEC::on works when changing threads", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on works when changing threads", "[adaptors][on]")
+  {
     exec::static_thread_pool pool{2};
-    bool called{false};
+    bool                     called{false};
     // launch some work on the thread pool
     ex::sender auto snd = ex::on(pool.get_scheduler(), ex::just())
                         | ex::then([&] { called = true; }) | _with_scheduler();
@@ -108,87 +120,96 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE("STDEXEC::on can be called with rvalue ref scheduler", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on can be called with rvalue ref scheduler", "[adaptors][on]")
+  {
     auto env = _make_env_with_sched();
     auto snd = ex::on(inline_scheduler{}, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{env_tag{}, env, 13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{env_tag{}, env, 13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("STDEXEC::on can be called with const ref scheduler", "[adaptors][on]") {
-    auto env = _make_env_with_sched();
-    const inline_scheduler sched;
-    auto snd = ex::on(sched, ex::just(13));
+  TEST_CASE("STDEXEC::on can be called with const ref scheduler", "[adaptors][on]")
+  {
+    auto                   env = _make_env_with_sched();
+    inline_scheduler const sched;
+    auto                   snd = ex::on(sched, ex::just(13));
     auto op = ex::connect(std::move(snd), expect_value_receiver{env_tag{}, env, 13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("STDEXEC::on can be called with ref scheduler", "[adaptors][on]") {
-    auto env = _make_env_with_sched();
+  TEST_CASE("STDEXEC::on can be called with ref scheduler", "[adaptors][on]")
+  {
+    auto             env = _make_env_with_sched();
     inline_scheduler sched;
-    auto snd = ex::on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{env_tag{}, env, 13});
+    auto             snd = ex::on(sched, ex::just(13));
+    auto             op  = ex::connect(std::move(snd), expect_value_receiver{env_tag{}, env, 13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("STDEXEC::on forwards set_error calls", "[adaptors][on]") {
-    auto env = _make_env_with_sched();
+  TEST_CASE("STDEXEC::on forwards set_error calls", "[adaptors][on]")
+  {
+    auto                                env = _make_env_with_sched();
     error_scheduler<std::exception_ptr> sched{std::exception_ptr{}};
-    auto snd = ex::on(sched, ex::just(13));
+    auto                                snd = ex::on(sched, ex::just(13));
     auto op = ex::connect(std::move(snd), expect_error_receiver{env, std::exception_ptr{}});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("STDEXEC::on forwards set_error calls of other types", "[adaptors][on]") {
-    auto env = _make_env_with_sched();
+  TEST_CASE("STDEXEC::on forwards set_error calls of other types", "[adaptors][on]")
+  {
+    auto                         env = _make_env_with_sched();
     error_scheduler<std::string> sched{std::string{"error"}};
-    auto snd = ex::on(sched, ex::just(13));
+    auto                         snd = ex::on(sched, ex::just(13));
     auto op = ex::connect(std::move(snd), expect_error_receiver{env, std::string{"error"}});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("STDEXEC::on forwards set_stopped calls", "[adaptors][on]") {
-    auto env = _make_env_with_sched();
+  TEST_CASE("STDEXEC::on forwards set_stopped calls", "[adaptors][on]")
+  {
+    auto              env = _make_env_with_sched();
     stopped_scheduler sched{};
-    auto snd = ex::on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{env});
+    auto              snd = ex::on(sched, ex::just(13));
+    auto              op  = ex::connect(std::move(snd), expect_stopped_receiver{env});
     ex::start(op);
     // The receiver checks if we receive the stopped signal
   }
 
-  TEST_CASE("STDEXEC::on has the values_type corresponding to the given values", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on has the values_type corresponding to the given values", "[adaptors][on]")
+  {
     inline_scheduler sched{};
 
     check_val_types<ex::__mset<pack<int>>>(ex::on(sched, ex::just(1)) | _with_scheduler());
-    check_val_types<ex::__mset<pack<int, double>>>(
-      ex::on(sched, ex::just(3, 0.14)) | _with_scheduler());
+    check_val_types<ex::__mset<pack<int, double>>>(ex::on(sched, ex::just(3, 0.14))
+                                                   | _with_scheduler());
     check_val_types<ex::__mset<pack<int, double, std::string>>>(
       ex::on(sched, ex::just(3, 0.14, std::string{"pi"})) | _with_scheduler());
   }
 
-  TEST_CASE("STDEXEC::on keeps error_types from scheduler's sender", "[adaptors][on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("STDEXEC::on keeps error_types from scheduler's sender", "[adaptors][on]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     check_err_types<ex::__mset<>>(ex::on(sched1, ex::just(1)) | _with_scheduler());
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::on(sched2, ex::just(2)) | _with_scheduler());
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::on(sched2, ex::just(2))
+                                                    | _with_scheduler());
     check_err_types<ex::__mset<int>>(ex::on(sched3, ex::just(3)) | _with_scheduler());
   }
 
-  TEST_CASE("STDEXEC::on keeps sends_stopped from scheduler's sender", "[adaptors][on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("STDEXEC::on keeps sends_stopped from scheduler's sender", "[adaptors][on]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::on(sched1, ex::just(1)) | _with_scheduler());
     check_sends_stopped<true>(ex::on(sched2, ex::just(2)) | _with_scheduler());
     check_sends_stopped<true>(ex::on(sched3, ex::just(3)) | _with_scheduler());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_on2.cpp b/test/stdexec/algos/adaptors/test_on2.cpp
index 6259e2487..8348155a9 100644
--- a/test/stdexec/algos/adaptors/test_on2.cpp
+++ b/test/stdexec/algos/adaptors/test_on2.cpp
@@ -22,27 +22,32 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   template <ex::scheduler Sched = inline_scheduler>
-  inline auto _with_scheduler(Sched sched = {}) {
+  inline auto _with_scheduler(Sched sched = {})
+  {
     return ex::write_env(ex::prop{ex::get_scheduler, std::move(sched)});
   }
 
-  TEST_CASE(
-    "STDEXEC::on transitions back to the receiver's scheduler when completing with a value",
-    "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on transitions back to the receiver's scheduler when completing with a value",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::then([&]() -> int {
-                      called = true;
-                      return 19;
-                    });
-
-    int recv_value{0};
+    auto snd_base = ex::just()
+                  | ex::then(
+                      [&]() -> int
+                      {
+                        called = true;
+                        return 19;
+                      });
+
+    int               recv_value{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
-    auto snd = ex::on(sched1, std::move(snd_base)) | _with_scheduler(sched2);
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto              snd = ex::on(sched1, std::move(snd_base)) | _with_scheduler(sched2);
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -62,20 +67,24 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE(
-    "STDEXEC::on transitions back to the receiver's scheduler when completing with an error",
-    "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on transitions back to the receiver's scheduler when completing with an "
+            "error",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::let_value([&]() {
-                      called = true;
-                      return ex::just_error(19);
-                    });
-
-    int recv_error{0};
+    auto snd_base = ex::just()
+                  | ex::let_value(
+                      [&]()
+                      {
+                        called = true;
+                        return ex::just_error(19);
+                      });
+
+    int               recv_error{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
-    auto snd = ex::on(sched1, std::move(snd_base)) | _with_scheduler(sched2);
-    auto op = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
+    auto              snd = ex::on(sched1, std::move(snd_base)) | _with_scheduler(sched2);
+    auto              op  = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -95,21 +104,25 @@ namespace {
     CHECK(recv_error == 19);
   }
 
-  TEST_CASE(
-    "inner STDEXEC::on transitions back to outer on's scheduler when completing with a value",
-    "[adaptors][on]") {
+  TEST_CASE("inner STDEXEC::on transitions back to outer on's scheduler when completing with a "
+            "value",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::then([&]() -> int {
-                      called = true;
-                      return 19;
-                    });
-
-    int recv_value{0};
+    auto snd_base = ex::just()
+                  | ex::then(
+                      [&]() -> int
+                      {
+                        called = true;
+                        return 19;
+                      });
+
+    int               recv_value{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     impulse_scheduler sched3;
     auto snd = ex::on(sched1, ex::on(sched2, std::move(snd_base))) | _with_scheduler(sched3);
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -146,21 +159,25 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE(
-    "inner STDEXEC::on transitions back to outer on's scheduler when completing with an error",
-    "[adaptors][on]") {
+  TEST_CASE("inner STDEXEC::on transitions back to outer on's scheduler when completing with an "
+            "error",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::let_value([&]() {
-                      called = true;
-                      return ex::just_error(19);
-                    });
-
-    int recv_error{0};
+    auto snd_base = ex::just()
+                  | ex::let_value(
+                      [&]()
+                      {
+                        called = true;
+                        return ex::just_error(19);
+                      });
+
+    int               recv_error{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     impulse_scheduler sched3;
     auto snd = ex::on(sched1, ex::on(sched2, std::move(snd_base))) | _with_scheduler(sched3);
-    auto op = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
+    auto op  = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -197,21 +214,24 @@ namespace {
     CHECK(recv_error == 19);
   }
 
-  TEST_CASE(
-    "STDEXEC::on(closure) transitions onto and back off of the scheduler when completing with a "
-    "value",
-    "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on(closure) transitions onto and back off of the scheduler when completing "
+            "with a "
+            "value",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto closure = ex::then([&]() -> int {
-      called = true;
-      return 19;
-    });
-
-    int recv_value{0};
+    auto closure = ex::then(
+      [&]() -> int
+      {
+        called = true;
+        return 19;
+      });
+
+    int               recv_value{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     auto snd = ex::just() | ex::on(sched1, std::move(closure)) | _with_scheduler(sched2);
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The closure shouldn't be started
@@ -231,21 +251,24 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE(
-    "STDEXEC::on(closure) transitions onto and back off of the scheduler when completing with "
-    "an error",
-    "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on(closure) transitions onto and back off of the scheduler when completing "
+            "with "
+            "an error",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto closure = ex::let_value([&]() {
-      called = true;
-      return ex::just_error(19);
-    });
-
-    int recv_error{0};
+    auto closure = ex::let_value(
+      [&]()
+      {
+        called = true;
+        return ex::just_error(19);
+      });
+
+    int               recv_error{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     auto snd = ex::just() | ex::on(sched1, std::move(closure)) | _with_scheduler(sched2);
-    auto op = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
+    auto op  = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The closure shouldn't be started
@@ -265,21 +288,24 @@ namespace {
     CHECK(recv_error == 19);
   }
 
-  TEST_CASE(
-    "inner STDEXEC::on(closure) transitions back to outer on's scheduler when completing with a "
-    "value",
-    "[adaptors][on]") {
+  TEST_CASE("inner STDEXEC::on(closure) transitions back to outer on's scheduler when completing "
+            "with a "
+            "value",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto closure = ex::then([&](int i) -> int {
-      called = true;
-      return i;
-    });
-
-    int recv_value{0};
+    auto closure = ex::then(
+      [&](int i) -> int
+      {
+        called = true;
+        return i;
+      });
+
+    int               recv_value{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     impulse_scheduler sched3;
-    auto snd = ex::on(sched1, ex::just(19)) | ex::on(sched2, std::move(closure))
+    auto              snd = ex::on(sched1, ex::just(19)) | ex::on(sched2, std::move(closure))
              | _with_scheduler(sched3);
     auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
@@ -318,21 +344,24 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE(
-    "inner STDEXEC::on(closure) transitions back to outer on's scheduler when completing with an "
-    "error",
-    "[adaptors][on]") {
+  TEST_CASE("inner STDEXEC::on(closure) transitions back to outer on's scheduler when completing "
+            "with an "
+            "error",
+            "[adaptors][on]")
+  {
     bool called{false};
-    auto closure = ex::let_value([&](int i) {
-      called = true;
-      return ex::just_error(i);
-    });
-
-    int recv_error{0};
+    auto closure = ex::let_value(
+      [&](int i)
+      {
+        called = true;
+        return ex::just_error(i);
+      });
+
+    int               recv_error{0};
     impulse_scheduler sched1;
     impulse_scheduler sched2;
     impulse_scheduler sched3;
-    auto snd = ex::on(sched1, ex::just(19)) | ex::on(sched2, std::move(closure))
+    auto              snd = ex::on(sched1, ex::just(19)) | ex::on(sched2, std::move(closure))
              | _with_scheduler(sched3);
     auto op = ex::connect(std::move(snd), expect_error_receiver_ex{recv_error});
     ex::start(op);
@@ -370,4 +399,4 @@ namespace {
     // Now the error is sent to the receiver
     CHECK(recv_error == 19);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_on3.cpp b/test/stdexec/algos/adaptors/test_on3.cpp
index 71b74b09d..c81129900 100644
--- a/test/stdexec/algos/adaptors/test_on3.cpp
+++ b/test/stdexec/algos/adaptors/test_on3.cpp
@@ -25,86 +25,100 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
   template <class Rcvr>
-  struct get_env_rcvr {
+  struct get_env_rcvr
+  {
     using receiver_concept = ex::receiver_t;
     Rcvr rcvr;
 
     template <class... Values>
-    void set_value(Values&&...) noexcept {
+    void set_value(Values&&...) noexcept
+    {
       auto env = ex::get_env(rcvr);
       ex::set_value(std::move(rcvr), std::move(env));
     }
 
     template <class Error>
-    void set_error(Error&& err) noexcept {
+    void set_error(Error&& err) noexcept
+    {
       ex::set_error(std::move(rcvr), std::forward<Error>(err));
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       ex::set_stopped(std::move(rcvr));
     }
 
     [[nodiscard]]
-    auto get_env() const noexcept {
+    auto get_env() const noexcept
+    {
       return ex::get_env(rcvr);
     }
   };
 
   template <class Sndr>
-  struct get_env_sender {
+  struct get_env_sender
+  {
     using sender_concept = ex::sender_t;
     Sndr sndr;
 
     template <ex::__decays_to<get_env_sender> Self, ex::receiver Rcvr>
-    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Rcvr rcvr) {
-      return ex::connect(
-        static_cast<Self&&>(self).sndr, get_env_rcvr<Rcvr>{static_cast<Rcvr&&>(rcvr)});
+    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Rcvr rcvr)
+    {
+      return ex::connect(static_cast<Self&&>(self).sndr,
+                         get_env_rcvr<Rcvr>{static_cast<Rcvr&&>(rcvr)});
     }
     STDEXEC_EXPLICIT_THIS_END(connect)
 
     template <ex::__decays_to<get_env_sender> Self, class Env>
-    static consteval auto get_completion_signatures() {
-      return ex::__try_make_completion_signatures<
-        ex::__copy_cvref_t<Self, Sndr>,
-        Env,
-        ex::completion_signatures<ex::set_value_t(Env)>,
-        ex::__mconst<ex::completion_signatures<>>
-      >{};
+    static consteval auto get_completion_signatures()
+    {
+      return ex::__try_make_completion_signatures<ex::__copy_cvref_t<Self, Sndr>,
+                                                  Env,
+                                                  ex::completion_signatures<ex::set_value_t(Env)>,
+                                                  ex::__mconst<ex::completion_signatures<>>>{};
     }
   };
 
-  struct probe_env_t {
+  struct probe_env_t
+  {
     template <ex::sender Sndr>
-    auto operator()(Sndr&& sndr) const {
+    auto operator()(Sndr&& sndr) const
+    {
       return get_env_sender<Sndr>{static_cast<Sndr&&>(sndr)};
     }
 
-    auto operator()() const {
+    auto operator()() const
+    {
       return ex::__closure(*this);
     }
   };
 
-  static const auto probe_env = probe_env_t{};
+  static auto const probe_env = probe_env_t{};
 
-  static const auto env = ex::prop{ex::get_scheduler, inline_scheduler{}};
+  static auto const env = ex::prop{ex::get_scheduler, inline_scheduler{}};
 
-  TEST_CASE("Can pass STDEXEC::on sender to start_detached", "[adaptors][on]") {
+  TEST_CASE("Can pass STDEXEC::on sender to start_detached", "[adaptors][on]")
+  {
     exec::start_detached(ex::on(inline_scheduler{}, ex::just()), env);
   }
 
-  TEST_CASE("Can pass STDEXEC::on sender to split", "[adaptors][on]") {
+  TEST_CASE("Can pass STDEXEC::on sender to split", "[adaptors][on]")
+  {
     auto snd = exec::split(ex::on(inline_scheduler{}, ex::just()), env);
     (void) snd;
   }
 
-  TEST_CASE("Can pass STDEXEC::on sender to ensure_started", "[adaptors][on]") {
+  TEST_CASE("Can pass STDEXEC::on sender to ensure_started", "[adaptors][on]")
+  {
     auto snd = exec::ensure_started(ex::on(inline_scheduler{}, ex::just()), env);
     (void) snd;
   }
 
-  TEST_CASE("Can pass STDEXEC::on sender to async_scope::spawn", "[adaptors][on]") {
+  TEST_CASE("Can pass STDEXEC::on sender to async_scope::spawn", "[adaptors][on]")
+  {
     exec::async_scope scope;
     impulse_scheduler sched;
     scope.spawn(ex::on(sched, ex::just()), env);
@@ -112,27 +126,34 @@ namespace {
     ex::sync_wait(scope.on_empty());
   }
 
-  TEST_CASE("Can pass STDEXEC::on sender to async_scope::spawn_future", "[adaptors][on]") {
+  TEST_CASE("Can pass STDEXEC::on sender to async_scope::spawn_future", "[adaptors][on]")
+  {
     exec::async_scope scope;
     impulse_scheduler sched;
-    auto fut = scope.spawn_future(ex::on(sched, ex::just(42)), env);
+    auto              fut = scope.spawn_future(ex::on(sched, ex::just(42)), env);
     sched.start_next();
     auto [i] = ex::sync_wait(std::move(fut)).value();
     CHECK(i == 42);
     ex::sync_wait(scope.on_empty());
   }
 
-  TEST_CASE("STDEXEC::on updates the current scheduler in the receiver", "[adaptors][on]") {
+  TEST_CASE("STDEXEC::on updates the current scheduler in the receiver", "[adaptors][on]")
+  {
     auto snd = ex::get_scheduler() | ex::on(inline_scheduler{}, probe_env())
-             | ex::then([]<class Env>(Env) noexcept {
-                 using Sched = ex::__call_result_t<ex::get_scheduler_t, Env>;
-                 static_assert(std::same_as<Sched, ex::run_loop::scheduler>);
-               })
-             | probe_env() | ex::then([]<class Env>(Env) noexcept {
-                 using Sched = ex::__call_result_t<ex::get_scheduler_t, Env>;
-                 static_assert(std::same_as<Sched, ex::run_loop::scheduler>);
-               });
+             | ex::then(
+                 []<class Env>(Env) noexcept
+                 {
+                   using Sched = ex::__call_result_t<ex::get_scheduler_t, Env>;
+                   static_assert(std::same_as<Sched, ex::run_loop::scheduler>);
+                 })
+             | probe_env()
+             | ex::then(
+                 []<class Env>(Env) noexcept
+                 {
+                   using Sched = ex::__call_result_t<ex::get_scheduler_t, Env>;
+                   static_assert(std::same_as<Sched, ex::run_loop::scheduler>);
+                 });
 
     ex::sync_wait(snd);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_spawn_future.cpp b/test/stdexec/algos/adaptors/test_spawn_future.cpp
index a1cc8dc17..9c27296ec 100644
--- a/test/stdexec/algos/adaptors/test_spawn_future.cpp
+++ b/test/stdexec/algos/adaptors/test_spawn_future.cpp
@@ -29,18 +29,20 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("future completion signature calculation works", "[adaptors][spawn_future]") {
+namespace
+{
+  TEST_CASE("future completion signature calculation works", "[adaptors][spawn_future]")
+  {
     {
       using expected = ex::completion_signatures<ex::set_stopped_t()>;
-      using actual = ex::__spawn_future::__future_completions_t<ex::env<>>;
+      using actual   = ex::__spawn_future::__future_completions_t<ex::env<>>;
 
       STATIC_REQUIRE(actual{} == expected{});
     }
 
     {
       using expected = ex::completion_signatures<ex::set_stopped_t(), ex::set_value_t()>;
-      using actual = ex::__spawn_future::__future_completions_t<ex::env<>, ex::set_value_t()>;
+      using actual   = ex::__spawn_future::__future_completions_t<ex::env<>, ex::set_value_t()>;
 
       STATIC_REQUIRE(actual{} == expected{});
     }
@@ -54,20 +56,20 @@ namespace {
     }
 
     {
-      using expected = ex::completion_signatures<
-        ex::set_stopped_t(),
-        ex::set_error_t(std::exception_ptr),
-        ex::set_value_t(std::string)
-      >;
+      using expected = ex::completion_signatures<ex::set_stopped_t(),
+                                                 ex::set_error_t(std::exception_ptr),
+                                                 ex::set_value_t(std::string)>;
       using actual =
-        ex::__spawn_future::__future_completions_t<ex::env<>, ex::set_value_t(const std::string&)>;
+        ex::__spawn_future::__future_completions_t<ex::env<>, ex::set_value_t(std::string const &)>;
 
       STATIC_REQUIRE(actual{} == expected{});
     }
   }
 
-  TEST_CASE("spawn_future(just(...)) is equivalent to just(...)", "[adaptors][spawn_future]") {
-    constexpr auto checkEquivalence = [](const ex::sender auto& sender) {
+  TEST_CASE("spawn_future(just(...)) is equivalent to just(...)", "[adaptors][spawn_future]")
+  {
+    constexpr auto checkEquivalence = [](ex::sender auto const & sender)
+    {
       CHECK(ex::sync_wait(sender) == ex::sync_wait(ex::spawn_future(sender, null_token{})));
     };
 
@@ -76,68 +78,83 @@ namespace {
     checkEquivalence(ex::just(42, std::string{"hello, world!"}));
   }
 
-  TEST_CASE("deferred futures work", "[adaptors][spawn_future]") {
+  TEST_CASE("deferred futures work", "[adaptors][spawn_future]")
+  {
     exec::static_thread_pool pool;
 
     std::atomic<bool> waiting{false};
     std::atomic<bool> go{false};
 
-    auto future = ex::spawn_future(
-      ex::starts_on(pool.get_scheduler(), ex::just() | ex::let_value([&]() noexcept {
-                                            waiting = true; // signal we've started running
-                                            waiting.notify_one();
-                                            go.wait(false);
-                                            return ex::just(42, std::string{"hello, world!"});
-                                          })),
-      null_token{});
+    auto future =
+      ex::spawn_future(ex::starts_on(pool.get_scheduler(),
+                                     ex::just()
+                                       | ex::let_value(
+                                         [&]() noexcept
+                                         {
+                                           waiting = true;  // signal we've started running
+                                           waiting.notify_one();
+                                           go.wait(false);
+                                           return ex::just(42, std::string{"hello, world!"});
+                                         })),
+                       null_token{});
 
     // wait for the signal that the spawned work has started running
     waiting.wait(false);
 
     std::atomic<bool> firstBranchStarted = false;
-    std::atomic<bool> futureCompleted = false;
+    std::atomic<bool> futureCompleted    = false;
 
     auto mainThreadId = std::this_thread::get_id();
 
-    ex::sync_wait(
-      ex::when_all(
-        ex::just(std::move(future)) | ex::let_value([&](auto& future) noexcept {
-          firstBranchStarted = true;
-          return std::move(future);
-        }) | ex::then([&](int i, std::string str) noexcept {
-          futureCompleted = true;
-          CHECK(i == 42);
-          CHECK(str == "hello, world!");
-
-          // we should be running on the pool thread
-          CHECK(std::this_thread::get_id() != mainThreadId);
-        }),
-        ex::just() | ex::then([&]() noexcept {
-          CHECK(std::this_thread::get_id() == mainThreadId);
-
-          CHECK(firstBranchStarted);
-          CHECK(!futureCompleted);
-          // release the spawned work
-          go = true;
-          go.notify_one();
-        })));
+    ex::sync_wait(ex::when_all(ex::just(std::move(future))
+                                 | ex::let_value(
+                                   [&](auto& future) noexcept
+                                   {
+                                     firstBranchStarted = true;
+                                     return std::move(future);
+                                   })
+                                 | ex::then(
+                                   [&](int i, std::string str) noexcept
+                                   {
+                                     futureCompleted = true;
+                                     CHECK(i == 42);
+                                     CHECK(str == "hello, world!");
+
+                                     // we should be running on the pool thread
+                                     CHECK(std::this_thread::get_id() != mainThreadId);
+                                   }),
+                               ex::just()
+                                 | ex::then(
+                                   [&]() noexcept
+                                   {
+                                     CHECK(std::this_thread::get_id() == mainThreadId);
+
+                                     CHECK(firstBranchStarted);
+                                     CHECK(!futureCompleted);
+                                     // release the spawned work
+                                     go = true;
+                                     go.notify_one();
+                                   })));
 
     CHECK(futureCompleted);
   }
 
-  TEST_CASE("spawn_future doesn't leak", "[adaptors][spawn_future]") {
-    counting_resource rsc;
+  TEST_CASE("spawn_future doesn't leak", "[adaptors][spawn_future]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
 
-    auto future = ex::spawn_future(
-      ex::read_env(ex::get_allocator) | ex::then([&](auto& envAlloc) noexcept {
-        CHECK(alloc == envAlloc);
-        return rsc.allocated();
-      }),
-      null_token{},
-      ex::prop(ex::get_allocator, alloc));
+    auto future = ex::spawn_future(ex::read_env(ex::get_allocator)
+                                     | ex::then(
+                                       [&](auto& envAlloc) noexcept
+                                       {
+                                         CHECK(alloc == envAlloc);
+                                         return rsc.allocated();
+                                       }),
+                                   null_token{},
+                                   ex::prop(ex::get_allocator, alloc));
 
     auto allocated = rsc.allocated();
 
@@ -148,24 +165,26 @@ namespace {
     CHECK(rsc.allocated() == 0);
   }
 
-  TEST_CASE(
-    "spawn_future reads an allocator from the sender's environment",
-    "[adaptors][spawn_future]") {
-    counting_resource rsc;
+  TEST_CASE("spawn_future reads an allocator from the sender's environment",
+            "[adaptors][spawn_future]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     scope_with_alloc scope{alloc};
 
     REQUIRE(rsc.allocated() == 0);
 
-    auto future = ex::spawn_future(
-      ex::read_env(ex::get_allocator) | ex::then([&](auto&& envAlloc) noexcept {
-        // we should've pulled the scope's allocator into our environment
-        CHECK(alloc == envAlloc);
+    auto future = ex::spawn_future(ex::read_env(ex::get_allocator)
+                                     | ex::then(
+                                       [&](auto&& envAlloc) noexcept
+                                       {
+                                         // we should've pulled the scope's allocator into our environment
+                                         CHECK(alloc == envAlloc);
 
-        return rsc.allocated();
-      }),
-      scope.get_token());
+                                         return rsc.allocated();
+                                       }),
+                                   scope.get_token());
 
     // we should've allocated some memory for the operation
     auto allocated = rsc.allocated();
@@ -176,14 +195,14 @@ namespace {
     CHECK(rsc.allocated() == 0);
   }
 
-  TEST_CASE(
-    "The allocator provided directly to spawn_future overrides the allocator in the sender's "
-    "environment",
-    "[consumers][spawn_future]") {
-
+  TEST_CASE("The allocator provided directly to spawn_future overrides the allocator in the "
+            "sender's "
+            "environment",
+            "[consumers][spawn_future]")
+  {
     counting_resource rsc1;
 
-    std::array<std::byte, 256> buffer{};
+    std::array<std::byte, 256>          buffer{};
     std::pmr::monotonic_buffer_resource bumpAlloc(buffer.data(), buffer.size());
 
     counting_resource rsc2(bumpAlloc);
@@ -198,17 +217,19 @@ namespace {
     CHECK(rsc1.allocated() == 0);
     CHECK(rsc2.allocated() == 0);
 
-    auto future = ex::spawn_future(
-      ex::read_env(ex::get_allocator) | ex::let_value([&](auto& envAlloc) noexcept {
-        // the allocator in the environment should be the one provided to spawn_future
-        // as an explicit argument and not the one provided by the scope
-        CHECK(alloc1 != envAlloc);
-        CHECK(alloc2 == envAlloc);
+    auto future = ex::spawn_future(ex::read_env(ex::get_allocator)
+                                     | ex::let_value(
+                                       [&](auto& envAlloc) noexcept
+                                       {
+                                         // the allocator in the environment should be the one provided to spawn_future
+                                         // as an explicit argument and not the one provided by the scope
+                                         CHECK(alloc1 != envAlloc);
+                                         CHECK(alloc2 == envAlloc);
 
-        return ex::just(rsc1.allocated(), rsc2.allocated());
-      }),
-      scope.get_token(),
-      ex::prop(ex::get_allocator, alloc2));
+                                         return ex::just(rsc1.allocated(), rsc2.allocated());
+                                       }),
+                                   scope.get_token(),
+                                   ex::prop(ex::get_allocator, alloc2));
 
     // we should have allocated some memory for the op from rsc2 but not from rsc
     auto allocated1 = rsc1.allocated();
@@ -222,14 +243,17 @@ namespace {
     CHECK(rsc2.allocated() == 0);
   }
 
-  TEST_CASE("spawn_future tolerates throwing scope tokens", "[consumers][spawn_future]") {
-    counting_resource rsc;
+  TEST_CASE("spawn_future tolerates throwing scope tokens", "[consumers][spawn_future]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
-    struct throwing_token : null_token {
-      const counting_resource* rsc;
+    struct throwing_token : null_token
+    {
+      counting_resource const * rsc;
 
-      assoc try_associate() const {
+      assoc try_associate() const
+      {
         CHECK(rsc->allocated() > 0);
         throw std::runtime_error("nope");
       }
@@ -238,9 +262,12 @@ namespace {
     REQUIRE(rsc.allocated() == 0);
 
     bool threw = false;
-    try {
+    try
+    {
       ex::spawn_future(ex::just(), throwing_token{{}, &rsc}, ex::prop(ex::get_allocator, alloc));
-    } catch (const std::runtime_error& e) {
+    }
+    catch (std::runtime_error const & e)
+    {
       threw = true;
       CHECK(std::string{"nope"} == e.what());
     }
@@ -250,37 +277,44 @@ namespace {
     CHECK(rsc.allocated() == 0);
   }
 
-  TEST_CASE("spawn_future tolerates expired scope tokens", "[consumers][spawn_future]") {
-    struct expired_token : null_token { // inherit the wrap method template
-      const counting_resource* rsc;
-      bool* tried;
-
-      struct assoc {
-        constexpr explicit operator bool() const noexcept {
+  TEST_CASE("spawn_future tolerates expired scope tokens", "[consumers][spawn_future]")
+  {
+    struct expired_token : null_token
+    {  // inherit the wrap method template
+      counting_resource const * rsc;
+      bool*                     tried;
+
+      struct assoc
+      {
+        constexpr explicit operator bool() const noexcept
+        {
           return false;
         }
 
-        constexpr assoc try_associate() const noexcept {
+        constexpr assoc try_associate() const noexcept
+        {
           return {};
         }
       };
 
-      assoc try_associate() const {
+      assoc try_associate() const
+      {
         CHECK(rsc->allocated() > 0);
         *tried = true;
         return {};
       }
     };
 
-    counting_resource rsc;
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
 
     bool triedToAssociate = false;
 
-    auto future = ex::spawn_future(
-      ex::just(), expired_token{{}, &rsc, &triedToAssociate}, ex::prop(ex::get_allocator, alloc));
+    auto future = ex::spawn_future(ex::just(),
+                                   expired_token{{}, &rsc, &triedToAssociate},
+                                   ex::prop(ex::get_allocator, alloc));
 
     CHECK(rsc.allocated() > 0);
 
@@ -290,10 +324,10 @@ namespace {
     CHECK(triedToAssociate);
   }
 
-  TEST_CASE(
-    "discarding a future sends a stop request to the spawned operation",
-    "[adaptors][spawn_future]") {
-    counting_resource rsc;
+  TEST_CASE("discarding a future sends a stop request to the spawned operation",
+            "[adaptors][spawn_future]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
@@ -306,24 +340,28 @@ namespace {
     std::atomic<bool> waitingForStopRequest{false};
 
     std::optional future = ex::spawn_future(
-      ex::starts_on(
-        pool.get_scheduler(),
-        ex::read_env(ex::get_stop_token) | ex::then([&](auto stopToken) noexcept {
-          auto callback = [&]() noexcept {
-            waitingForStopRequest = true;
-            waitingForStopRequest.notify_one();
-          };
-
-          using callback_t = ex::stop_callback_for_t<decltype(stopToken), decltype(callback)>;
-
-	  [[maybe_unused]]
-          callback_t registeredCallback(std::move(stopToken), std::move(callback));
-
-          workStarted = true;
-          workStarted.notify_one();
-
-          waitingForStopRequest.wait(false);
-        })),
+      ex::starts_on(pool.get_scheduler(),
+                    ex::read_env(ex::get_stop_token)
+                      | ex::then(
+                        [&](auto stopToken) noexcept
+                        {
+                          auto callback = [&]() noexcept
+                          {
+                            waitingForStopRequest = true;
+                            waitingForStopRequest.notify_one();
+                          };
+
+                          using callback_t =
+                            ex::stop_callback_for_t<decltype(stopToken), decltype(callback)>;
+
+                          [[maybe_unused]]
+                          callback_t registeredCallback(std::move(stopToken), std::move(callback));
+
+                          workStarted = true;
+                          workStarted.notify_one();
+
+                          waitingForStopRequest.wait(false);
+                        })),
       scope.get_token(),
       ex::prop(ex::get_allocator, alloc));
 
@@ -338,70 +376,79 @@ namespace {
     CHECK(rsc.allocated() == 0);
   }
 
-  struct never {
+  struct never
+  {
     using sender_concept = ex::sender_t;
 
     template <class Sender, class... Env>
     static consteval auto get_completion_signatures(Sender&&, Env&&...) noexcept
-      -> ex::completion_signatures<ex::set_stopped_t()> {
+      -> ex::completion_signatures<ex::set_stopped_t()>
+    {
       return {};
     }
 
     template <class Receiver>
-    struct opstate {
+    struct opstate
+    {
       using operation_state_concept = ex::operation_state_t;
 
       template <ex::receiver Rcvr>
         requires std::constructible_from<Receiver, Rcvr>
       explicit opstate(Rcvr&& r) noexcept
-        : rcvr_(std::forward<Rcvr>(r)) {
-      }
+        : rcvr_(std::forward<Rcvr>(r))
+      {}
 
       opstate(opstate&&) = delete;
 
-      ~opstate() {
-      }
+      ~opstate() {}
 
-      void start() & noexcept {
+      void start() & noexcept
+      {
         std::construct_at(&callback_, ex::get_stop_token(ex::get_env(rcvr_)), callback{this});
       }
 
      private:
-      struct callback {
+      struct callback
+      {
         opstate* self_;
 
-        void operator()() noexcept {
+        void operator()() noexcept
+        {
           std::destroy_at(&self_->callback_);
           ex::set_stopped(std::move(self_->rcvr_));
         }
       };
 
-      using stoken_t = ex::stop_token_of_t<ex::env_of_t<Receiver>>;
+      using stoken_t   = ex::stop_token_of_t<ex::env_of_t<Receiver>>;
       using callback_t = stoken_t::template callback_type<callback>;
 
       Receiver rcvr_;
-      union {
+      union
+      {
         callback_t callback_;
       };
     };
 
     template <ex::receiver_of<ex::completion_signatures<ex::set_stopped_t()>> Receiver>
-    auto connect(Receiver&& receiver) noexcept {
+    auto connect(Receiver&& receiver) noexcept
+    {
       return opstate<std::remove_cvref_t<Receiver>>{std::forward<Receiver>(receiver)};
     }
   };
 
-  TEST_CASE("abandoning a future-wrapped never-sender works properly", "[adaptors][spawn_future]") {
+  TEST_CASE("abandoning a future-wrapped never-sender works properly", "[adaptors][spawn_future]")
+  {
     // this test exercises the part of __abandon that handles the spawned work completing
     // during the call __abandon makes to __stopSource_.request_stop()
 
-    counting_resource rsc;
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
 
-    std::optional future =
-      ex::spawn_future(never{}, null_token{}, ex::prop(ex::get_allocator, alloc));
+    std::optional future = ex::spawn_future(never{},
+                                            null_token{},
+                                            ex::prop(ex::get_allocator, alloc));
 
     CHECK(rsc.allocated() > 0);
 
@@ -409,4 +456,4 @@ namespace {
 
     CHECK(rsc.allocated() == 0);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_starts_on.cpp b/test/stdexec/algos/adaptors/test_starts_on.cpp
index ff1c5f6fe..ef307cb75 100644
--- a/test/stdexec/algos/adaptors/test_starts_on.cpp
+++ b/test/stdexec/algos/adaptors/test_starts_on.cpp
@@ -22,7 +22,7 @@
 #include <test_common/schedulers.hpp>
 #include <test_common/type_helpers.hpp>
 
-#include <chrono> // IWYU pragma: keep for std::chrono_literals
+#include <chrono>  // IWYU pragma: keep for std::chrono_literals
 
 namespace ex = STDEXEC;
 
@@ -32,32 +32,37 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-namespace {
+namespace
+{
 
-  TEST_CASE("starts_on returns a sender", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on returns a sender", "[adaptors][starts_on]")
+  {
     auto snd = ex::starts_on(inline_scheduler{}, ex::just(13));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("starts_on with environment returns a sender", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on with environment returns a sender", "[adaptors][starts_on]")
+  {
     auto snd = ex::starts_on(inline_scheduler{}, ex::just(13));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("starts_on simple example", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on simple example", "[adaptors][starts_on]")
+  {
     auto snd = ex::starts_on(inline_scheduler{}, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("starts_on calls the receiver when the scheduler dictates", "[adaptors][starts_on]") {
-    int recv_value{0};
+  TEST_CASE("starts_on calls the receiver when the scheduler dictates", "[adaptors][starts_on]")
+  {
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto snd = ex::starts_on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto              snd = ex::starts_on(sched, ex::just(13));
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task; no effect expected
     CHECK(recv_value == 0);
@@ -67,19 +72,21 @@ namespace {
     CHECK(recv_value == 13);
   }
 
-  TEST_CASE(
-    "starts_on calls the given sender when the scheduler dictates",
-    "[adaptors][starts_on]") {
+  TEST_CASE("starts_on calls the given sender when the scheduler dictates", "[adaptors][starts_on]")
+  {
     bool called{false};
-    auto snd_base = ex::just() | ex::then([&]() -> int {
-                      called = true;
-                      return 19;
-                    });
-
-    int recv_value{0};
+    auto snd_base = ex::just()
+                  | ex::then(
+                      [&]() -> int
+                      {
+                        called = true;
+                        return 19;
+                      });
+
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto snd = ex::starts_on(sched, std::move(snd_base));
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
+    auto              snd = ex::starts_on(sched, std::move(snd_base));
+    auto              op  = ex::connect(std::move(snd), expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task
     // The base sender shouldn't be started
@@ -93,9 +100,10 @@ namespace {
     CHECK(recv_value == 19);
   }
 
-  TEST_CASE("starts_on works when changing threads", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on works when changing threads", "[adaptors][starts_on]")
+  {
     exec::static_thread_pool pool{2};
-    std::atomic<bool> called{false};
+    std::atomic<bool>        called{false};
     {
       // lunch some work on the thread pool
       ex::sender auto snd = ex::starts_on(pool.get_scheduler(), ex::just())
@@ -111,56 +119,62 @@ namespace {
     REQUIRE(called);
   }
 
-  TEST_CASE("starts_on can be called with rvalue ref scheduler", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on can be called with rvalue ref scheduler", "[adaptors][starts_on]")
+  {
     auto snd = ex::starts_on(inline_scheduler{}, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("starts_on can be called with const ref scheduler", "[adaptors][starts_on]") {
-    const inline_scheduler sched;
-    auto snd = ex::starts_on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+  TEST_CASE("starts_on can be called with const ref scheduler", "[adaptors][starts_on]")
+  {
+    inline_scheduler const sched;
+    auto                   snd = ex::starts_on(sched, ex::just(13));
+    auto                   op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("starts_on can be called with ref scheduler", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on can be called with ref scheduler", "[adaptors][starts_on]")
+  {
     inline_scheduler sched;
-    auto snd = ex::starts_on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto             snd = ex::starts_on(sched, ex::just(13));
+    auto             op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("starts_on forwards set_error calls", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on forwards set_error calls", "[adaptors][starts_on]")
+  {
     error_scheduler<std::exception_ptr> sched{std::exception_ptr{}};
-    auto snd = ex::starts_on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto                                snd = ex::starts_on(sched, ex::just(13));
+    auto                                op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("starts_on forwards set_error calls of other types", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on forwards set_error calls of other types", "[adaptors][starts_on]")
+  {
     error_scheduler<std::string> sched{std::string{"error"}};
-    auto snd = ex::starts_on(sched, ex::just(13));
+    auto                         snd = ex::starts_on(sched, ex::just(13));
     auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"error"}});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("starts_on forwards set_stopped calls", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on forwards set_stopped calls", "[adaptors][starts_on]")
+  {
     stopped_scheduler sched{};
-    auto snd = ex::starts_on(sched, ex::just(13));
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto              snd = ex::starts_on(sched, ex::just(13));
+    auto              op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     // The receiver checks if we receive the stopped signal
   }
 
-  TEST_CASE(
-    "starts_on has the values_type corresponding to the given values",
-    "[adaptors][starts_on]") {
+  TEST_CASE("starts_on has the values_type corresponding to the given values",
+            "[adaptors][starts_on]")
+  {
     inline_scheduler sched{};
 
     check_val_types<ex::__mset<pack<int>>>(ex::starts_on(sched, ex::just(1)));
@@ -169,9 +183,10 @@ namespace {
       ex::starts_on(sched, ex::just(3, 0.14, std::string{"pi"})));
   }
 
-  TEST_CASE("starts_on keeps error_types from scheduler's sender", "[adaptors][starts_on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("starts_on keeps error_types from scheduler's sender", "[adaptors][starts_on]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     check_err_types<ex::__mset<>>(ex::starts_on(sched1, ex::just(1)));
@@ -179,9 +194,10 @@ namespace {
     check_err_types<ex::__mset<int>>(ex::starts_on(sched3, ex::just(3)));
   }
 
-  TEST_CASE("starts_on keeps sends_stopped from scheduler's sender", "[adaptors][starts_on]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("starts_on keeps sends_stopped from scheduler's sender", "[adaptors][starts_on]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::starts_on(sched1, ex::just(1)));
@@ -190,45 +206,53 @@ namespace {
   }
 
   // Return a different sender when we invoke this custom defined starts_on implementation
-  struct starts_on_test_domain {
+  struct starts_on_test_domain
+  {
     template <ex::sender_expr_for<ex::starts_on_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, const auto&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender&&, auto const &...)
+    {
       return ex::just(std::string{"Hello, world!"});
     }
   };
 
-  TEST_CASE("starts_on can be customized", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on can be customized", "[adaptors][starts_on]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<starts_on_test_domain> sched;
-    auto snd = ex::starts_on(sched, ex::just(std::string{"world"}));
+    auto        snd = ex::starts_on(sched, ex::just(std::string{"world"}));
     std::string res;
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
+    auto        op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
     ex::start(op);
     REQUIRE(res == "Hello, world!");
   }
 
-  struct move_checker {
+  struct move_checker
+  {
     move_checker() noexcept = default;
 
-    move_checker(const move_checker& other) noexcept {
+    move_checker(move_checker const & other) noexcept
+    {
       REQUIRE(other.valid);
       valid = true;
     }
 
-    auto operator=(const move_checker& other) noexcept -> move_checker& {
+    auto operator=(move_checker const & other) noexcept -> move_checker&
+    {
       REQUIRE(other.valid);
       valid = true;
       return *this;
     }
 
-    move_checker(move_checker&& other) noexcept {
+    move_checker(move_checker&& other) noexcept
+    {
       other.valid = false;
-      valid = true;
+      valid       = true;
     }
 
-    auto operator=(move_checker&& other) noexcept -> move_checker& {
+    auto operator=(move_checker&& other) noexcept -> move_checker&
+    {
       other.valid = false;
-      valid = true;
+      valid       = true;
       return *this;
     }
 
@@ -236,38 +260,46 @@ namespace {
     bool valid{true};
   };
 
-  struct move_checking_inline_scheduler {
+  struct move_checking_inline_scheduler
+  {
     [[nodiscard]]
-    auto schedule() const noexcept {
+    auto schedule() const noexcept
+    {
       return sender{};
     }
 
-    auto operator==(const move_checking_inline_scheduler&) const noexcept -> bool {
+    auto operator==(move_checking_inline_scheduler const &) const noexcept -> bool
+    {
       return true;
     }
 
    private:
     template <typename Receiver>
-    struct opstate : immovable {
-      void start() & noexcept {
+    struct opstate : immovable
+    {
+      void start() & noexcept
+      {
         ex::set_value(static_cast<Receiver&&>(rcvr_));
       }
 
       Receiver rcvr_;
     };
 
-    struct sender {
-      using sender_concept = STDEXEC::sender_t;
+    struct sender
+    {
+      using sender_concept        = STDEXEC::sender_t;
       using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
       template <typename Receiver>
       [[nodiscard]]
-      auto connect(Receiver rcvr) const -> opstate<Receiver> {
+      auto connect(Receiver rcvr) const -> opstate<Receiver>
+      {
         return {{}, static_cast<Receiver&&>(rcvr)};
       }
 
       [[nodiscard]]
-      auto get_env() const noexcept {
+      auto get_env() const noexcept
+      {
         return sched_attrs(move_checking_inline_scheduler(), ex::set_value);
       }
     };
@@ -275,11 +307,12 @@ namespace {
     move_checker mc_;
   };
 
-  TEST_CASE("starts_on does not reference a moved-from scheduler", "[adaptors][starts_on]") {
+  TEST_CASE("starts_on does not reference a moved-from scheduler", "[adaptors][starts_on]")
+  {
     move_checking_inline_scheduler is;
-    ex::sender auto snd = ex::starts_on(is, ex::just()) | ex::then([] { });
+    ex::sender auto                snd = ex::starts_on(is, ex::just()) | ex::then([] {});
     ex::sync_wait(std::move(snd));
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/algos/adaptors/test_stop_when.cpp b/test/stdexec/algos/adaptors/test_stop_when.cpp
index e7389a265..31802a6cd 100644
--- a/test/stdexec/algos/adaptors/test_stop_when.cpp
+++ b/test/stdexec/algos/adaptors/test_stop_when.cpp
@@ -16,17 +16,20 @@
  */
 
 #include <catch2/catch.hpp>
+#include <stdexec/__detail/__stop_when.hpp>
 #include <stdexec/execution.hpp>
 #include <stdexec/stop_token.hpp>
-#include <stdexec/__detail/__stop_when.hpp>
 #include <test_common/receivers.hpp>
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("stop-when of an unstoppable token is the identity", "[adaptors][stop-when]") {
-    auto snd = ex::just(42);
-    auto checkIdentity = [](auto&& snd) {
+namespace
+{
+  TEST_CASE("stop-when of an unstoppable token is the identity", "[adaptors][stop-when]")
+  {
+    auto snd           = ex::just(42);
+    auto checkIdentity = [](auto&& snd)
+    {
       auto&& result = ex::__stop_when(std::forward<decltype(snd)>(snd), ex::never_stop_token{});
 
       REQUIRE(&snd == &result);
@@ -37,22 +40,23 @@ namespace {
     checkIdentity(std::move(snd));
   }
 
-  TEST_CASE("stop-when(just(), token) returns a sender", "[adaptors][stop-when]") {
+  TEST_CASE("stop-when(just(), token) returns a sender", "[adaptors][stop-when]")
+  {
     ex::inplace_stop_source source;
-    auto snd = ex::__stop_when(ex::just(), source.get_token());
+    auto                    snd = ex::__stop_when(ex::just(), source.get_token());
     STATIC_REQUIRE(ex::sender<decltype(snd)>);
     wait_for_value(snd);
   }
 
-  auto isTokenStoppable() {
+  auto isTokenStoppable()
+  {
     return ex::read_env(ex::get_stop_token)
          | ex::then([](auto token) noexcept { return token.stop_possible(); });
   }
 
-  TEST_CASE(
-    "stop-when substitutes its token when the receiver's token is unstoppable",
-    "[adaptors][stop-when]") {
-
+  TEST_CASE("stop-when substitutes its token when the receiver's token is unstoppable",
+            "[adaptors][stop-when]")
+  {
     // check that, by default, wait_for_value provides an unstoppable stop token
     wait_for_value(isTokenStoppable(), false);
 
@@ -65,63 +69,74 @@ namespace {
     wait_for_value(ex::__stop_when(isTokenStoppable(), source.get_token()), true);
   }
 
-  TEST_CASE(
-    "stop-when fuses its token with the receiver's when both are stoppable",
-    "[adaptors][stop-when]") {
+  TEST_CASE("stop-when fuses its token with the receiver's when both are stoppable",
+            "[adaptors][stop-when]")
+  {
     ex::inplace_stop_source source;
-    wait_for_value(
-      ex::__stop_when(ex::__stop_when(isTokenStoppable(), source.get_token()), source.get_token()),
-      true);
+    wait_for_value(ex::__stop_when(ex::__stop_when(isTokenStoppable(), source.get_token()),
+                                   source.get_token()),
+                   true);
   }
 
   template <std::invocable Fn>
-  ex::sender auto make_stop_callback(Fn&& fn) noexcept {
+  ex::sender auto make_stop_callback(Fn&& fn) noexcept
+  {
     return ex::read_env(ex::get_stop_token)
-         | ex::then([fn = std::forward<Fn>(fn)](auto token) mutable noexcept {
-             using cb_t = decltype(token)::template callback_type<std::remove_cvref_t<Fn>>;
-             return std::optional<cb_t>(std::in_place, std::move(token), std::move(fn));
-           });
+         | ex::then(
+             [fn = std::forward<Fn>(fn)](auto token) mutable noexcept
+             {
+               using cb_t = decltype(token)::template callback_type<std::remove_cvref_t<Fn>>;
+               return std::optional<cb_t>(std::in_place, std::move(token), std::move(fn));
+             });
   }
 
-  TEST_CASE("callbacks registered with stop-when's token can be invoked", "[adaptors][stop-when]") {
-    int invokeCount = 0;
-    auto snd = make_stop_callback([&invokeCount]() noexcept { invokeCount++; });
+  TEST_CASE("callbacks registered with stop-when's token can be invoked", "[adaptors][stop-when]")
+  {
+    int  invokeCount = 0;
+    auto snd         = make_stop_callback([&invokeCount]() noexcept { invokeCount++; });
 
     {
       ex::inplace_stop_source source;
-      wait_for_value(
-        snd | ex::then([&](auto&& optCallback) noexcept {
-          source.request_stop();
-          optCallback.reset();
-          return invokeCount;
-        }),
-        0);
+      wait_for_value(snd
+                       | ex::then(
+                         [&](auto&& optCallback) noexcept
+                         {
+                           source.request_stop();
+                           optCallback.reset();
+                           return invokeCount;
+                         }),
+                     0);
     }
 
     {
       ex::inplace_stop_source source;
 
-      wait_for_value(
-        ex::__stop_when(snd, source.get_token()) | ex::then([&](auto&& optCallback) noexcept {
-          source.request_stop();
-          optCallback.reset();
-          return invokeCount;
-        }),
-        1);
+      wait_for_value(ex::__stop_when(snd, source.get_token())
+                       | ex::then(
+                         [&](auto&& optCallback) noexcept
+                         {
+                           source.request_stop();
+                           optCallback.reset();
+                           return invokeCount;
+                         }),
+                     1);
     }
 
     {
       ex::inplace_stop_source source1;
       ex::inplace_stop_source source2;
 
-      wait_for_value(
-        ex::__stop_when(snd, source2.get_token()) | ex::then([&](auto&& optCallback) noexcept {
-          source1.request_stop();
-          source2.request_stop();
-          optCallback.reset();
-          return invokeCount;
-        }) | ex::write_env(ex::prop(ex::get_stop_token, source1.get_token())),
-        2);
+      wait_for_value(ex::__stop_when(snd, source2.get_token())
+                       | ex::then(
+                         [&](auto&& optCallback) noexcept
+                         {
+                           source1.request_stop();
+                           source2.request_stop();
+                           optCallback.reset();
+                           return invokeCount;
+                         })
+                       | ex::write_env(ex::prop(ex::get_stop_token, source1.get_token())),
+                     2);
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_stopped_as_error.cpp b/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
index 6a17f0574..4230c5d7b 100644
--- a/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
+++ b/test/stdexec/algos/adaptors/test_stopped_as_error.cpp
@@ -23,51 +23,59 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("stopped_as_error returns a sender", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error returns a sender", "[adaptors][stopped_as_error]")
+  {
     auto snd = ex::stopped_as_error(ex::just(11), -1);
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("stopped_as_error with environment returns a sender", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error with environment returns a sender", "[adaptors][stopped_as_error]")
+  {
     auto snd = ex::stopped_as_error(ex::just(11), -1);
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("stopped_as_error simple example", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error simple example", "[adaptors][stopped_as_error]")
+  {
     stopped_scheduler sched;
-    auto snd = ex::stopped_as_error(ex::just(11) | ex::continues_on(sched), -1);
-    auto op = ex::connect(std::move(snd), expect_error_receiver{-1});
+    auto              snd = ex::stopped_as_error(ex::just(11) | ex::continues_on(sched), -1);
+    auto              op  = ex::connect(std::move(snd), expect_error_receiver{-1});
     ex::start(op);
   }
 
-  TEST_CASE("stopped_as_error can we piped", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error can we piped", "[adaptors][stopped_as_error]")
+  {
     inline_scheduler sched;
-    ex::sender auto snd = ex::just(11) | ex::continues_on(sched)
+    ex::sender auto  snd = ex::just(11) | ex::continues_on(sched)
                         | ex::stopped_as_error(std::exception_ptr{});
     auto op = ex::connect(std::move(snd), expect_value_receiver{11});
     ex::start(op);
   }
 
-  TEST_CASE("stopped_as_error can work with `just_stopped`", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error can work with `just_stopped`", "[adaptors][stopped_as_error]")
+  {
     ex::sender auto snd = ex::just_stopped() | ex::stopped_as_error(-1);
-    auto op = ex::connect(std::move(snd), expect_error_receiver{-1});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{-1});
     ex::start(op);
   }
 
-  TEST_CASE("stopped_as_error can we waited on", "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error can we waited on", "[adaptors][stopped_as_error]")
+  {
     inline_scheduler sched;
-    ex::sender auto snd = ex::just(11) | ex::continues_on(sched)
+    ex::sender auto  snd = ex::just(11) | ex::continues_on(sched)
                         | ex::stopped_as_error(std::exception_ptr{});
     wait_for_value(std::move(snd), 11);
   }
 
-  TEST_CASE("stopped_as_error using error_code error type", "[adaptors][stopped_as_error]") {
-    impulse_scheduler sched; // scheduler that can send stopped signals
-    ex::sender auto snd = ex::just(11) | ex::continues_on(sched)
+  TEST_CASE("stopped_as_error using error_code error type", "[adaptors][stopped_as_error]")
+  {
+    impulse_scheduler sched;  // scheduler that can send stopped signals
+    ex::sender auto   snd = ex::just(11) | ex::continues_on(sched)
                         | ex::stopped_as_error(std::error_code(1, std::generic_category()));
     check_val_types<ex::__mset<pack<int>>>(snd);
     check_err_types<ex::__mset<std::error_code>>(snd);
@@ -78,12 +86,12 @@ namespace {
     sched.start_next();
   }
 
-  TEST_CASE(
-    "stopped_as_error using error_code error type, for stopped signal",
-    "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error using error_code error type, for stopped signal",
+            "[adaptors][stopped_as_error]")
+  {
     stopped_scheduler sched;
-    std::error_code errcode(1, std::generic_category());
-    ex::sender auto snd = ex::just(11) | ex::continues_on(sched) | ex::stopped_as_error(errcode);
+    std::error_code   errcode(1, std::generic_category());
+    ex::sender auto   snd = ex::just(11) | ex::continues_on(sched) | ex::stopped_as_error(errcode);
     check_val_types<ex::__mset<pack<int>>>(snd);
     check_err_types<ex::__mset<std::error_code>>(snd);
     check_sends_stopped<false>(snd);
@@ -95,57 +103,56 @@ namespace {
   // `stopped_as_error` is implemented in terms of `let_error`, so the tests for `let_error` cover
   // more ground.
 
-  TEST_CASE(
-    "stopped_as_error keeps values_type from input sender",
-    "[adaptors][stopped_as_error]") {
+  TEST_CASE("stopped_as_error keeps values_type from input sender", "[adaptors][stopped_as_error]")
+  {
     inline_scheduler sched;
-    check_val_types<ex::__mset<pack<int>>>(
-      ex::just(23) | ex::continues_on(sched) | ex::stopped_as_error(-1));
-    check_val_types<ex::__mset<pack<double>>>(
-      ex::just(std::numbers::pi) | ex::continues_on(sched) | ex::stopped_as_error(-1));
+    check_val_types<ex::__mset<pack<int>>>(ex::just(23) | ex::continues_on(sched)
+                                           | ex::stopped_as_error(-1));
+    check_val_types<ex::__mset<pack<double>>>(ex::just(std::numbers::pi) | ex::continues_on(sched)
+                                              | ex::stopped_as_error(-1));
   }
 
-  TEST_CASE(
-    "stopped_as_error keeps error_types from input sender",
-    "[adaptors][stopped_as_error]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("stopped_as_error keeps error_types from input sender", "[adaptors][stopped_as_error]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{-1};
 
-    check_err_types<ex::__mset<>>(
-      ex::just(11) | ex::continues_on(sched1) | ex::stopped_as_error(std::exception_ptr{}));
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just(13) | ex::continues_on(sched2) | ex::stopped_as_error(std::exception_ptr{}));
+    check_err_types<ex::__mset<>>(ex::just(11) | ex::continues_on(sched1)
+                                  | ex::stopped_as_error(std::exception_ptr{}));
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just(13) | ex::continues_on(sched2)
+                                                    | ex::stopped_as_error(std::exception_ptr{}));
 
     check_err_types<ex::__mset<int, std::exception_ptr>>(
       ex::just(13) | ex::continues_on(sched3) | ex::stopped_as_error(std::exception_ptr{}));
   }
 
-  TEST_CASE("stopped_as_error can add more types to error_types", "[adaptors][stopped_as_error]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("stopped_as_error can add more types to error_types", "[adaptors][stopped_as_error]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{-1};
 
-    check_err_types<ex::__mset<>>(
-      ex::just(11) | ex::continues_on(sched1) | ex::stopped_as_error(-1));
-    check_err_types<ex::__mset<std::exception_ptr, int>>(
-      ex::just(13) | ex::continues_on(sched2) | ex::stopped_as_error(-1));
+    check_err_types<ex::__mset<>>(ex::just(11) | ex::continues_on(sched1)
+                                  | ex::stopped_as_error(-1));
+    check_err_types<ex::__mset<std::exception_ptr, int>>(ex::just(13) | ex::continues_on(sched2)
+                                                         | ex::stopped_as_error(-1));
 
-    check_err_types<ex::__mset<int>>(
-      ex::just(13) | ex::continues_on(sched3) | ex::stopped_as_error(-1));
+    check_err_types<ex::__mset<int>>(ex::just(13) | ex::continues_on(sched3)
+                                     | ex::stopped_as_error(-1));
 
-    check_err_types<ex::__mset<>>(
-      ex::just(11) | ex::continues_on(sched1) | ex::stopped_as_error(-1)
-      | ex::stopped_as_error(std::string{"err"}));
+    check_err_types<ex::__mset<>>(ex::just(11) | ex::continues_on(sched1) | ex::stopped_as_error(-1)
+                                  | ex::stopped_as_error(std::string{"err"}));
   }
 
-  TEST_CASE("stopped_as_error overrides sends_stopped to false", "[adaptors][stopped_as_error]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("stopped_as_error overrides sends_stopped to false", "[adaptors][stopped_as_error]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::just(1) | ex::continues_on(sched1) | ex::stopped_as_error(-1));
     check_sends_stopped<false>(ex::just(2) | ex::continues_on(sched2) | ex::stopped_as_error(-1));
     check_sends_stopped<false>(ex::just(3) | ex::continues_on(sched3) | ex::stopped_as_error(-1));
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp b/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
index 56348f9c2..c905a96bc 100644
--- a/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
+++ b/test/stdexec/algos/adaptors/test_stopped_as_optional.cpp
@@ -24,35 +24,41 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  struct potentially_throwing_query {
-    constexpr auto operator()(ex::__ignore) const noexcept(false) -> int {
+namespace
+{
+  struct potentially_throwing_query
+  {
+    constexpr auto operator()(ex::__ignore) const noexcept(false) -> int
+    {
       return 42;
     }
   };
 
-  TEST_CASE("stopped_as_optional returns a sender", "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional returns a sender", "[adaptors][stopped_as_optional]")
+  {
     auto snd = ex::stopped_as_optional(ex::just(11));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "stopped_as_optional with environment returns a sender",
-    "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional with environment returns a sender",
+            "[adaptors][stopped_as_optional]")
+  {
     auto snd = ex::stopped_as_optional(ex::just(11));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("stopped_as_optional simple example", "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional simple example", "[adaptors][stopped_as_optional]")
+  {
     stopped_scheduler sched;
-    auto snd = ex::stopped_as_optional(ex::just(11) | ex::continues_on(sched));
-    auto op = ex::connect(std::move(snd), expect_value_receiver{std::optional<int>{}});
+    auto              snd = ex::stopped_as_optional(ex::just(11) | ex::continues_on(sched));
+    auto              op = ex::connect(std::move(snd), expect_value_receiver{std::optional<int>{}});
     ex::start(op);
   }
 
-  TEST_CASE("stopped_as_optional can we waited on", "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional can we waited on", "[adaptors][stopped_as_optional]")
+  {
     ex::sender auto snd = ex::just(11) | ex::stopped_as_optional();
     wait_for_value(std::move(snd), std::optional<int>{11});
   }
@@ -64,63 +70,65 @@ namespace {
   //   static_assert(!ex::sender_to<decltype(snd), expect_error_receiver<>>);
   // }
 
-  TEST_CASE(
-    "stopped_as_optional shall not work with senders that have multiple alternatives",
-    "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional shall not work with senders that have multiple alternatives",
+            "[adaptors][stopped_as_optional]")
+  {
     ex::sender auto in_snd = ex::read_env(potentially_throwing_query{})
-                           | ex::let_error(
-                               [](std::exception_ptr) { return ex::just(std::string{"err"}); });
+                           | ex::let_error([](std::exception_ptr)
+                                           { return ex::just(std::string{"err"}); });
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(in_snd));
     using snd_t = decltype(std::move(in_snd) | ex::stopped_as_optional());
     static_assert(!ex::sender_to<snd_t, expect_error_receiver<>>);
   }
 
-  TEST_CASE("stopped_as_optional forwards errors", "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional forwards errors", "[adaptors][stopped_as_optional]")
+  {
     error_scheduler sched;
     ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::stopped_as_optional();
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("stopped_as_optional doesn't forward cancellation", "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional doesn't forward cancellation", "[adaptors][stopped_as_optional]")
+  {
     stopped_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::stopped_as_optional();
+    ex::sender auto   snd = ex::just(13) | ex::continues_on(sched) | ex::stopped_as_optional();
     wait_for_value(std::move(snd), std::optional<int>{});
   }
 
-  TEST_CASE(
-    "stopped_as_optional adds std::optional to values_type",
-    "[adaptors][stopped_as_optional]") {
+  TEST_CASE("stopped_as_optional adds std::optional to values_type",
+            "[adaptors][stopped_as_optional]")
+  {
     check_val_types<ex::__mset<pack<std::optional<int>>>>(ex::just(23) | ex::stopped_as_optional());
-    check_val_types<ex::__mset<pack<std::optional<double>>>>(
-      ex::just(std::numbers::pi) | ex::stopped_as_optional());
+    check_val_types<ex::__mset<pack<std::optional<double>>>>(ex::just(std::numbers::pi)
+                                                             | ex::stopped_as_optional());
   }
 
-  TEST_CASE(
-    "stopped_as_optional keeps error_types from input sender",
-    "[adaptors][stopped_as_optional]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("stopped_as_optional keeps error_types from input sender",
+            "[adaptors][stopped_as_optional]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{-1};
 
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just(11) | ex::continues_on(sched1) | ex::stopped_as_optional());
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just(13) | ex::continues_on(sched2) | ex::stopped_as_optional());
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just(11) | ex::continues_on(sched1)
+                                                    | ex::stopped_as_optional());
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just(13) | ex::continues_on(sched2)
+                                                    | ex::stopped_as_optional());
 
-    check_err_types<ex::__mset<std::exception_ptr, int>>(
-      ex::just(13) | ex::continues_on(sched3) | ex::stopped_as_optional());
+    check_err_types<ex::__mset<std::exception_ptr, int>>(ex::just(13) | ex::continues_on(sched3)
+                                                         | ex::stopped_as_optional());
   }
 
-  TEST_CASE(
-    "stopped_as_optional overrides sends_stopped to false",
-    "[adaptors][stopped_as_optional]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("stopped_as_optional overrides sends_stopped to false",
+            "[adaptors][stopped_as_optional]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::just(1) | ex::continues_on(sched1) | ex::stopped_as_optional());
     check_sends_stopped<false>(ex::just(2) | ex::continues_on(sched2) | ex::stopped_as_optional());
     check_sends_stopped<false>(ex::just(3) | ex::continues_on(sched3) | ex::stopped_as_optional());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_then.cpp b/test/stdexec/algos/adaptors/test_then.cpp
index d96518aee..d19a86815 100644
--- a/test/stdexec/algos/adaptors/test_then.cpp
+++ b/test/stdexec/algos/adaptors/test_then.cpp
@@ -24,165 +24,196 @@
 namespace ex = STDEXEC;
 
 // Check that the `then` algorithm is correctly forwarding the __is_scheduler_affine query
-static_assert(ex::__is_scheduler_affine<decltype(ex::just() | ex::then([] { }))>);
+static_assert(ex::__is_scheduler_affine<decltype(ex::just() | ex::then([] {}))>);
 static_assert(
-  ex::__completes_inline<ex::set_value_t, decltype(ex::get_env(ex::just() | ex::then([] { })))>);
+  ex::__completes_inline<ex::set_value_t, decltype(ex::get_env(ex::just() | ex::then([] {})))>);
 
-namespace {
-  TEST_CASE("then returns a sender", "[adaptors][then]") {
-    auto snd = ex::then(ex::just(), [] { });
+namespace
+{
+  TEST_CASE("then returns a sender", "[adaptors][then]")
+  {
+    auto snd = ex::then(ex::just(), [] {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("then with environment returns a sender", "[adaptors][then]") {
-    auto snd = ex::then(ex::just(), [] { });
+  TEST_CASE("then with environment returns a sender", "[adaptors][then]")
+  {
+    auto snd = ex::then(ex::just(), [] {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("then simple example", "[adaptors][then]") {
+  TEST_CASE("then simple example", "[adaptors][then]")
+  {
     bool called{false};
     auto snd = ex::then(ex::just(), [&] { called = true; });
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("then can be piped", "[adaptors][then]") {
-    ex::sender auto snd = ex::just() | ex::then([] { });
+  TEST_CASE("then can be piped", "[adaptors][then]")
+  {
+    ex::sender auto snd = ex::just() | ex::then([] {});
     (void) snd;
   }
 
-  TEST_CASE("then returning void can we waited on", "[adaptors][then]") {
-    ex::sender auto snd = ex::just() | ex::then([] { });
+  TEST_CASE("then returning void can we waited on", "[adaptors][then]")
+  {
+    ex::sender auto snd = ex::just() | ex::then([] {});
     ex::sync_wait(std::move(snd));
   }
 
-  TEST_CASE("then can be used to transform the value", "[adaptors][then]") {
+  TEST_CASE("then can be used to transform the value", "[adaptors][then]")
+  {
     auto snd = ex::just(13) | ex::then([](int x) -> int { return 2 * x + 1; });
     wait_for_value(std::move(snd), 27);
   }
 
-  TEST_CASE("then can be used to change the value type", "[adaptors][then]") {
+  TEST_CASE("then can be used to change the value type", "[adaptors][then]")
+  {
     auto snd = ex::just(3) | ex::then([](int x) -> double { return x + 0.1415; });
-    wait_for_value(std::move(snd), 3.1415); // NOLINT(modernize-use-std-numbers)
+    wait_for_value(std::move(snd), 3.1415);  // NOLINT(modernize-use-std-numbers)
   }
 
-  TEST_CASE("then can be used with multiple parameters", "[adaptors][then]") {
+  TEST_CASE("then can be used with multiple parameters", "[adaptors][then]")
+  {
     auto snd = ex::just(3, 0.1415) | ex::then([](int x, double y) -> double { return x + y; });
-    wait_for_value(std::move(snd), 3.1415); // NOLINT(modernize-use-std-numbers)
+    wait_for_value(std::move(snd), 3.1415);  // NOLINT(modernize-use-std-numbers)
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("then can throw, and set_error will be called", "[adaptors][then]") {
+  TEST_CASE("then can throw, and set_error will be called", "[adaptors][then]")
+  {
     auto snd = ex::just(13) | ex::then([](int) -> int { throw std::logic_error{"err"}; });
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("then can be used with just_error", "[adaptors][then]") {
+  TEST_CASE("then can be used with just_error", "[adaptors][then]")
+  {
     ex::sender auto snd = ex::just_error(std::string{"err"}) | ex::then([]() -> int { return 17; });
-    auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"err"}});
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{std::string{"err"}});
     ex::start(op);
   }
 
-  TEST_CASE("then can be used with just_stopped", "[adaptors][then]") {
+  TEST_CASE("then can be used with just_stopped", "[adaptors][then]")
+  {
     ex::sender auto snd = ex::just_stopped() | ex::then([]() -> int { return 17; });
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto            op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("then function is not called on error", "[adaptors][then]") {
-    bool called{false};
+  TEST_CASE("then function is not called on error", "[adaptors][then]")
+  {
+    bool            called{false};
     error_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::then([&](int x) -> int {
-                            called = true;
-                            return x + 5;
-                          });
+    ex::sender auto snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::then(
+                            [&](int x) -> int
+                            {
+                              called = true;
+                              return x + 5;
+                            });
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE("then function is not called when cancelled", "[adaptors][then]") {
-    bool called{false};
+  TEST_CASE("then function is not called when cancelled", "[adaptors][then]")
+  {
+    bool              called{false};
     stopped_scheduler sched;
-    ex::sender auto snd = ex::just(13) | ex::continues_on(sched) | ex::then([&](int x) -> int {
-                            called = true;
-                            return x + 5;
-                          });
+    ex::sender auto   snd = ex::just(13) | ex::continues_on(sched)
+                        | ex::then(
+                            [&](int x) -> int
+                            {
+                              called = true;
+                              return x + 5;
+                            });
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     CHECK_FALSE(called);
   }
 
-  TEST_CASE("then advertises completion schedulers", "[adaptors][then]") {
+  TEST_CASE("then advertises completion schedulers", "[adaptors][then]")
+  {
     ex::run_loop loop;
-    auto sched = loop.get_scheduler();
+    auto         sched = loop.get_scheduler();
 
-    SECTION("for value channel") {
-      ex::sender auto snd = ex::schedule(sched) | ex::then([] { });
+    SECTION("for value channel")
+    {
+      ex::sender auto snd = ex::schedule(sched) | ex::then([] {});
       REQUIRE(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(snd)) == sched);
     }
   }
 
-  TEST_CASE("then forwards env", "[adaptors][then]") {
-    SECTION("returns env by value") {
+  TEST_CASE("then forwards env", "[adaptors][then]")
+  {
+    SECTION("returns env by value")
+    {
       auto snd = just_with_env<value_env, int>{.env_ = value_env{100}, .values_ = {0}}
-               | ex::then([](int) { });
+               | ex::then([](int) {});
       CHECK(value_query(ex::get_env(snd)) == 100);
     }
 
-    SECTION("returns env by reference") {
-      auto snd = just_with_env<const value_env&, int>{.env_ = value_env{100}, .values_ = {0}}
-               | ex::then([](int) { });
+    SECTION("returns env by reference")
+    {
+      auto snd = just_with_env<value_env const &, int>{.env_ = value_env{100}, .values_ = {0}}
+               | ex::then([](int) {});
       CHECK(value_query(ex::get_env(snd)) == 100);
     }
   }
 
-  TEST_CASE("then has the values_type corresponding to the given values", "[adaptors][then]") {
+  TEST_CASE("then has the values_type corresponding to the given values", "[adaptors][then]")
+  {
     check_val_types<ex::__mset<pack<int>>>(ex::just() | ex::then([] { return 7; }));
     check_val_types<ex::__mset<pack<double>>>(ex::just() | ex::then([] { return 3.14; }));
-    check_val_types<ex::__mset<pack<std::string>>>(
-      ex::just() | ex::then([] { return std::string{"hello"}; }));
+    check_val_types<ex::__mset<pack<std::string>>>(ex::just()
+                                                   | ex::then([] { return std::string{"hello"}; }));
   }
 
-  TEST_CASE("then keeps error_types from input sender", "[adaptors][then]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("then keeps error_types from input sender", "[adaptors][then]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
-    check_err_types<ex::__mset<>>(
-      ex::just() | ex::continues_on(sched1) | ex::then([]() noexcept { }));
-    check_err_types<ex::__mset<std::exception_ptr>>(
-      ex::just() | ex::continues_on(sched2) | ex::then([]() noexcept { }));
-    check_err_types<ex::__mset<std::exception_ptr, int>>(
-      ex::just() | ex::continues_on(sched3) | ex::then([] { }));
+    check_err_types<ex::__mset<>>(ex::just() | ex::continues_on(sched1)
+                                  | ex::then([]() noexcept {}));
+    check_err_types<ex::__mset<std::exception_ptr>>(ex::just() | ex::continues_on(sched2)
+                                                    | ex::then([]() noexcept {}));
+    check_err_types<ex::__mset<std::exception_ptr, int>>(ex::just() | ex::continues_on(sched3)
+                                                         | ex::then([] {}));
   }
 
-  TEST_CASE("then keeps sends_stopped from input sender", "[adaptors][then]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("then keeps sends_stopped from input sender", "[adaptors][then]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
-    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1) | ex::then([] { }));
-    check_sends_stopped<true>(ex::just() | ex::continues_on(sched2) | ex::then([] { }));
-    check_sends_stopped<true>(ex::just() | ex::continues_on(sched3) | ex::then([] { }));
+    check_sends_stopped<false>(ex::just() | ex::continues_on(sched1) | ex::then([] {}));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched2) | ex::then([] {}));
+    check_sends_stopped<true>(ex::just() | ex::continues_on(sched3) | ex::then([] {}));
   }
 
   // Return a different sender when we invoke this custom defined then implementation
-  struct then_test_domain {
+  struct then_test_domain
+  {
     template <ex::sender_expr_for<ex::then_t> Sender, class... Env>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&&, Env&&...) {
+    static auto transform_sender(STDEXEC::set_value_t, Sender &&, Env &&...)
+    {
       return ex::just(std::string{"ciao"});
     }
   };
 
-  TEST_CASE("then can be customized early", "[adaptors][then]") {
+  TEST_CASE("then can be customized early", "[adaptors][then]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<then_test_domain> sched;
     auto snd = ex::just(std::string{"hello"}) | ex::continues_on(sched)
@@ -190,12 +221,13 @@ namespace {
     wait_for_value(std::move(snd), std::string{"ciao"});
   }
 
-  TEST_CASE("then can be customized late", "[adaptors][then]") {
+  TEST_CASE("then can be customized late", "[adaptors][then]")
+  {
     // The customization will return a different value
     basic_inline_scheduler<then_test_domain> sched;
-    auto snd = ex::just(std::string{"hello"})
+    auto                                     snd = ex::just(std::string{"hello"})
              | ex::on(sched, ex::then([](std::string x) { return x + ", world"; }))
              | ex::write_env(ex::prop{ex::get_scheduler, inline_scheduler()});
     wait_for_value(std::move(snd), std::string{"ciao"});
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_then_fail1.cpp b/test/stdexec/algos/adaptors/test_then_fail1.cpp
index 7baab0e37..3fe0e892b 100644
--- a/test/stdexec/algos/adaptors/test_then_fail1.cpp
+++ b/test/stdexec/algos/adaptors/test_then_fail1.cpp
@@ -18,8 +18,9 @@
 
 namespace ex = STDEXEC;
 
-auto main() -> int {
-  ex::sender auto snd = ex::just(42) | ex::then([](int*) { });
+auto main() -> int
+{
+  ex::sender auto snd = ex::just(42) | ex::then([](int*) {});
   // build error: _FUNCTION_IS_NOT_CALLABLE_WITH_THE_GIVEN_ARGUMENTS_.*_WITH_FUNCTION_.*_WITH_ARGUMENTS_
   STDEXEC::sync_wait(std::move(snd));
 }
diff --git a/test/stdexec/algos/adaptors/test_transfer_when_all.cpp b/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
index d7064e56d..fd1b56757 100644
--- a/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
+++ b/test/stdexec/algos/adaptors/test_transfer_when_all.cpp
@@ -22,7 +22,7 @@
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
 namespace ex = STDEXEC;
 
@@ -32,104 +32,119 @@ namespace ex = STDEXEC;
 // For testing `transfer_when_all_with_variant`, we just check a couple of examples, check
 // customization, and we assume it's implemented in terms of `transfer_when_all`.
 
-namespace {
+namespace
+{
 
-  TEST_CASE("transfer_when_all returns a sender", "[adaptors][transfer_when_all]") {
+  TEST_CASE("transfer_when_all returns a sender", "[adaptors][transfer_when_all]")
+  {
     auto snd = ex::transfer_when_all(inline_scheduler{}, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "transfer_when_all with environment returns a sender",
-    "[adaptors][transfer_when_all]") {
+  TEST_CASE("transfer_when_all with environment returns a sender", "[adaptors][transfer_when_all]")
+  {
     auto snd = ex::transfer_when_all(inline_scheduler{}, ex::just(3), ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("transfer_when_all simple example", "[adaptors][transfer_when_all]") {
-    auto snd = ex::transfer_when_all(inline_scheduler{}, ex::just(3), ex::just(0.1415));
+  TEST_CASE("transfer_when_all simple example", "[adaptors][transfer_when_all]")
+  {
+    auto snd  = ex::transfer_when_all(inline_scheduler{}, ex::just(3), ex::just(0.1415));
     auto snd1 = std::move(snd) | ex::then([](int x, double y) { return x + y; });
-    auto op = ex::connect(
-      std::move(snd1), expect_value_receiver{3.1415}); // NOLINT(modernize-use-std-numbers)
+    auto op   = ex::connect(std::move(snd1),
+                          expect_value_receiver{3.1415});  // NOLINT(modernize-use-std-numbers)
     ex::start(op);
   }
 
-  TEST_CASE("transfer_when_all with no senders", "[adaptors][transfer_when_all]") {
+  TEST_CASE("transfer_when_all with no senders", "[adaptors][transfer_when_all]")
+  {
     auto snd = ex::transfer_when_all(inline_scheduler{});
-    auto op = ex::connect(std::move(snd), expect_void_receiver{});
+    auto op  = ex::connect(std::move(snd), expect_void_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE(
-    "transfer_when_all transfers the result when the scheduler dictates",
-    "[adaptors][transfer_when_all]") {
+  TEST_CASE("transfer_when_all transfers the result when the scheduler dictates",
+            "[adaptors][transfer_when_all]")
+  {
     impulse_scheduler sched;
-    auto snd = ex::transfer_when_all(sched, ex::just(3), ex::just(0.1415));
-    auto snd1 = std::move(snd) | ex::then([](int x, double y) { return x + y; });
-    double res{0.0};
-    auto op = ex::connect(std::move(snd1), expect_value_receiver_ex{res});
+    auto              snd  = ex::transfer_when_all(sched, ex::just(3), ex::just(0.1415));
+    auto              snd1 = std::move(snd) | ex::then([](int x, double y) { return x + y; });
+    double            res{0.0};
+    auto              op = ex::connect(std::move(snd1), expect_value_receiver_ex{res});
     ex::start(op);
     CHECK(res == 0.0);
     sched.start_next();
     CHECK(res == 3.1415);
   }
 
-  TEST_CASE(
-    "transfer_when_all with no senders transfers the result",
-    "[adaptors][transfer_when_all]") {
+  TEST_CASE("transfer_when_all with no senders transfers the result",
+            "[adaptors][transfer_when_all]")
+  {
     impulse_scheduler sched;
-    auto snd = ex::transfer_when_all(sched);
-    auto snd1 = std::move(snd) | ex::then([]() { return true; });
-    bool res{false};
-    auto op = ex::connect(std::move(snd1), expect_value_receiver_ex{res});
+    auto              snd  = ex::transfer_when_all(sched);
+    auto              snd1 = std::move(snd) | ex::then([]() { return true; });
+    bool              res{false};
+    auto              op = ex::connect(std::move(snd1), expect_value_receiver_ex{res});
     ex::start(op);
     CHECK(!res);
     sched.start_next();
     CHECK(res);
   }
 
-  TEST_CASE("transfer_when_all_with_variant returns a sender", "[adaptors][transfer_when_all]") {
-    auto snd =
-      ex::transfer_when_all_with_variant(inline_scheduler{}, ex::just(3), ex::just(0.1415));
+  TEST_CASE("transfer_when_all_with_variant returns a sender", "[adaptors][transfer_when_all]")
+  {
+    auto snd = ex::transfer_when_all_with_variant(inline_scheduler{},
+                                                  ex::just(3),
+                                                  ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE(
-    "transfer_when_all_with_variant with environment returns a sender",
-    "[adaptors][transfer_when_all]") {
-    auto snd =
-      ex::transfer_when_all_with_variant(inline_scheduler{}, ex::just(3), ex::just(0.1415));
+  TEST_CASE("transfer_when_all_with_variant with environment returns a sender",
+            "[adaptors][transfer_when_all]")
+  {
+    auto snd = ex::transfer_when_all_with_variant(inline_scheduler{},
+                                                  ex::just(3),
+                                                  ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("transfer_when_all_with_variant basic example", "[adaptors][transfer_when_all]") {
-    ex::sender auto snd =
-      ex::transfer_when_all_with_variant(inline_scheduler{}, ex::just(2), ex::just(3.14));
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int>>{2}, std::variant<std::tuple<double>>{3.14});
+  TEST_CASE("transfer_when_all_with_variant basic example", "[adaptors][transfer_when_all]")
+  {
+    ex::sender auto snd = ex::transfer_when_all_with_variant(inline_scheduler{},
+                                                             ex::just(2),
+                                                             ex::just(3.14));
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int>>{2},
+                   std::variant<std::tuple<double>>{3.14});
   }
 
-  namespace {
+  namespace
+  {
     template <class Tag, auto Fun>
-    struct basic_domain {
+    struct basic_domain
+    {
       template <ex::sender_expr_for<Tag> Sender, class Env>
-      auto transform_sender(STDEXEC::set_value_t, Sender&&, const Env&) const {
+      auto transform_sender(STDEXEC::set_value_t, Sender &&, Env const &) const
+      {
         return Fun();
       }
     };
-  } // anonymous namespace
+  }  // anonymous namespace
 
-  TEST_CASE("transfer_when_all works with custom domain", "[adaptors][transfer_when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("transfer_when_all works with custom domain", "[adaptors][transfer_when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::transfer_when_all_t, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::transfer_when_all_t, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
       auto snd = ex::transfer_when_all(scheduler(), ex::just(3), ex::just(0.1415));
@@ -139,15 +154,17 @@ namespace {
     }
   }
 
-  TEST_CASE(
-    "transfer_when_all_with_variant works with custom domain",
-    "[adaptors][transfer_when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("transfer_when_all_with_variant works with custom domain",
+            "[adaptors][transfer_when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::transfer_when_all_with_variant_t, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::transfer_when_all_with_variant_t, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
       auto snd = ex::transfer_when_all_with_variant(scheduler(), ex::just(3), ex::just(0.1415));
@@ -156,26 +173,30 @@ namespace {
       domain dom = ex::get_completion_domain<ex::set_value_t>(ex::get_env(snd));
     }
 
-    SECTION("late customization") {
-      using domain = basic_domain<ex::transfer_when_all_with_variant_t, hello>;
+    SECTION("late customization")
+    {
+      using domain    = basic_domain<ex::transfer_when_all_with_variant_t, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd = ex::starts_on(
-        scheduler(),
-        ex::transfer_when_all_with_variant(inline_scheduler(), ex::just(3), ex::just(0.1415)));
+      auto snd = ex::starts_on(scheduler(),
+                               ex::transfer_when_all_with_variant(inline_scheduler(),
+                                                                  ex::just(3),
+                                                                  ex::just(0.1415)));
       wait_for_value(std::move(snd), std::string{"hello world"});
     }
   }
 
-  TEST_CASE(
-    "transfer_when_all_with_variant finds transfer_when_all customizations",
-    "[adaptors][transfer_when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("transfer_when_all_with_variant finds transfer_when_all customizations",
+            "[adaptors][transfer_when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::transfer_when_all_t, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::transfer_when_all_t, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
       auto snd = ex::transfer_when_all_with_variant(scheduler(), ex::just(3), ex::just(0.1415));
@@ -184,14 +205,16 @@ namespace {
       domain dom = ex::get_completion_domain<ex::set_value_t>(ex::get_env(snd));
     }
 
-    SECTION("late customization") {
-      using domain = basic_domain<ex::transfer_when_all_t, hello>;
+    SECTION("late customization")
+    {
+      using domain    = basic_domain<ex::transfer_when_all_t, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd = ex::starts_on(
-        scheduler(),
-        ex::transfer_when_all_with_variant(inline_scheduler(), ex::just(3), ex::just(0.1415)));
+      auto snd = ex::starts_on(scheduler(),
+                               ex::transfer_when_all_with_variant(inline_scheduler(),
+                                                                  ex::just(3),
+                                                                  ex::just(0.1415)));
       wait_for_value(std::move(snd), std::string{"hello world"});
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_upon_error.cpp b/test/stdexec/algos/adaptors/test_upon_error.cpp
index 33645a51b..67d9206cd 100644
--- a/test/stdexec/algos/adaptors/test_upon_error.cpp
+++ b/test/stdexec/algos/adaptors/test_upon_error.cpp
@@ -22,34 +22,41 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("upon_error returns a sender", "[adaptors][upon_error]") {
-    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}), [](std::exception_ptr) { });
+  TEST_CASE("upon_error returns a sender", "[adaptors][upon_error]")
+  {
+    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}), [](std::exception_ptr) {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("upon_error with environment returns a sender", "[adaptors][upon_error]") {
-    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}), [](std::exception_ptr) { });
+  TEST_CASE("upon_error with environment returns a sender", "[adaptors][upon_error]")
+  {
+    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}), [](std::exception_ptr) {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("upon_error simple example", "[adaptors][upon_error]") {
+  TEST_CASE("upon_error simple example", "[adaptors][upon_error]")
+  {
     bool called{false};
-    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}), [&](std::exception_ptr) {
-      called = true;
-      return 0;
-    });
-    auto op = ex::connect(std::move(snd), expect_value_receiver{0});
+    auto snd = ex::upon_error(ex::just_error(std::exception_ptr{}),
+                              [&](std::exception_ptr)
+                              {
+                                called = true;
+                                return 0;
+                              });
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{0});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
 
-  TEST_CASE("upon_error with no-error input sender", "[adaptors][upon_error]") {
+  TEST_CASE("upon_error with no-error input sender", "[adaptors][upon_error]")
+  {
     auto snd = ex::upon_error(ex::just(), []() -> double { return 0.0; });
     static_assert(ex::sender<decltype(snd)>);
 
@@ -60,61 +67,70 @@ namespace {
   }
 
   template <typename R>
-  struct oper : immovable {
+  struct oper : immovable
+  {
     R recv_;
 
-    void start() & noexcept {
+    void start() & noexcept
+    {
       ex::set_value(static_cast<R&&>(recv_), 0);
     }
   };
 
-  struct Error1 { };
+  struct Error1
+  {};
 
-  struct Error2 { };
+  struct Error2
+  {};
 
-  struct Error3 { };
+  struct Error3
+  {};
 
-  struct Error4 { };
+  struct Error4
+  {};
 
   template <class... AdditionalCompletions>
-  struct many_error_sender {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      AdditionalCompletions...,
-      ex::set_error_t(Error1),
-      ex::set_error_t(Error2),
-      ex::set_error_t(Error3)
-    >;
+  struct many_error_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<AdditionalCompletions...,
+                                                            ex::set_error_t(Error1),
+                                                            ex::set_error_t(Error2),
+                                                            ex::set_error_t(Error3)>;
 
     template <typename R>
-    auto connect(R&& r) const -> oper<R> {
+    auto connect(R&& r) const -> oper<R>
+    {
       return {{}, static_cast<R&&>(r)};
     }
   };
 
-  TEST_CASE("upon_error many input error types", "[adaptors][upon_error]") {
+  TEST_CASE("upon_error many input error types", "[adaptors][upon_error]")
+  {
     {
-      auto s = many_error_sender<>{} | ex::upon_error([](auto e) {
-                 if constexpr (std::same_as<decltype(e), Error3>) {
-                   return Error4{};
-                 } else {
-                   return e;
-                 }
-                 STDEXEC_UNREACHABLE();
-               });
+      auto s = many_error_sender<>{}
+             | ex::upon_error(
+                 [](auto e)
+                 {
+                   if constexpr (std::same_as<decltype(e), Error3>)
+                   {
+                     return Error4{};
+                   }
+                   else
+                   {
+                     return e;
+                   }
+                   STDEXEC_UNREACHABLE();
+                 });
 
       using S = decltype(s);
       static_assert(ex::sender<S>);
       using completion_sigs = decltype(ex::get_completion_signatures(s, ex::env<>{}));
-      static_assert(ex::__mset_eq<
-                    ex::__mset<
-                      ex::set_error_t(std::exception_ptr),
-                      ex::set_value_t(Error1),
-                      ex::set_value_t(Error2),
-                      ex::set_value_t(Error4)
-                    >,
-                    completion_sigs
-      >);
+      static_assert(ex::__mset_eq<ex::__mset<ex::set_error_t(std::exception_ptr),
+                                             ex::set_value_t(Error1),
+                                             ex::set_value_t(Error2),
+                                             ex::set_value_t(Error4)>,
+                                  completion_sigs>);
     }
 
     {
@@ -123,10 +139,9 @@ namespace {
       using S = decltype(s);
       static_assert(ex::sender<S>);
       using completion_sigs = decltype(ex::get_completion_signatures(s, ex::env<>{}));
-      static_assert(ex::__mset_eq<
-                    ex::__mset<ex::set_error_t(std::exception_ptr), ex::set_value_t(int)>,
-                    completion_sigs
-      >);
+      static_assert(
+        ex::__mset_eq<ex::__mset<ex::set_error_t(std::exception_ptr), ex::set_value_t(int)>,
+                      completion_sigs>);
     }
 
     {
@@ -136,14 +151,10 @@ namespace {
       using S = decltype(s);
       static_assert(ex::sender<S>);
       using completion_sigs = decltype(ex::get_completion_signatures(s, ex::env<>{}));
-      static_assert(ex::__mset_eq<
-                    ex::__mset<
-                      ex::set_error_t(std::exception_ptr),
-                      ex::set_value_t(double),
-                      ex::set_value_t(int)
-                    >,
-                    completion_sigs
-      >);
+      static_assert(ex::__mset_eq<ex::__mset<ex::set_error_t(std::exception_ptr),
+                                             ex::set_value_t(double),
+                                             ex::set_value_t(int)>,
+                                  completion_sigs>);
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_upon_stopped.cpp b/test/stdexec/algos/adaptors/test_upon_stopped.cpp
index 2a6cbb49a..febdbb12d 100644
--- a/test/stdexec/algos/adaptors/test_upon_stopped.cpp
+++ b/test/stdexec/algos/adaptors/test_upon_stopped.cpp
@@ -22,31 +22,37 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   // TODO: implement upon_stopped
-  TEST_CASE("upon_stopped returns a sender", "[adaptors][upon_stopped]") {
-    auto snd = ex::upon_stopped(ex::just_stopped(), []() { });
+  TEST_CASE("upon_stopped returns a sender", "[adaptors][upon_stopped]")
+  {
+    auto snd = ex::upon_stopped(ex::just_stopped(), []() {});
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("upon_stopped with environment returns a sender", "[adaptors][upon_stopped]") {
-    auto snd = ex::upon_stopped(ex::just_stopped(), []() { });
+  TEST_CASE("upon_stopped with environment returns a sender", "[adaptors][upon_stopped]")
+  {
+    auto snd = ex::upon_stopped(ex::just_stopped(), []() {});
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("upon_stopped simple example", "[adaptors][upon_stopped]") {
+  TEST_CASE("upon_stopped simple example", "[adaptors][upon_stopped]")
+  {
     bool called{false};
-    auto snd = ex::upon_stopped(ex::just_stopped(), [&]() {
-      called = true;
-      return 0;
-    });
-    auto op = ex::connect(std::move(snd), expect_value_receiver{0});
+    auto snd = ex::upon_stopped(ex::just_stopped(),
+                                [&]()
+                                {
+                                  called = true;
+                                  return 0;
+                                });
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{0});
     ex::start(op);
     // The receiver checks that it's called
     // we also check that the function was invoked
     CHECK(called);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_when_all.cpp b/test/stdexec/algos/adaptors/test_when_all.cpp
index 9d0305ee1..cc1bbafe7 100644
--- a/test/stdexec/algos/adaptors/test_when_all.cpp
+++ b/test/stdexec/algos/adaptors/test_when_all.cpp
@@ -29,118 +29,136 @@ namespace ex = STDEXEC;
 // For testing `when_all_with_variant`, we just check a couple of examples, check customization, and
 // we assume it's implemented in terms of `when_all`.
 
-namespace {
+namespace
+{
 
-  TEST_CASE("when_all returns a sender", "[adaptors][when_all]") {
+  TEST_CASE("when_all returns a sender", "[adaptors][when_all]")
+  {
     auto snd = ex::when_all(ex::just(3), ex::just(0.1415));
     static_assert(ex::sender<decltype(snd)>);
     static_assert(noexcept(ex::connect(snd, expect_error_receiver{})));
     (void) snd;
   }
 
-  TEST_CASE("when_all with environment returns a sender", "[adaptors][when_all]") {
+  TEST_CASE("when_all with environment returns a sender", "[adaptors][when_all]")
+  {
     auto snd = ex::when_all(ex::just(3), ex::just(0.1415));
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("when_all simple example", "[adaptors][when_all]") {
-    auto snd = ex::when_all(ex::just(3), ex::just(0.1415));
+  TEST_CASE("when_all simple example", "[adaptors][when_all]")
+  {
+    auto snd  = ex::when_all(ex::just(3), ex::just(0.1415));
     auto snd1 = std::move(snd) | ex::then([](int x, double y) { return x + y; });
-    auto op = ex::connect(
-      std::move(snd1), expect_value_receiver{3.1415}); // NOLINT(modernize-use-std-numbers)
+    auto op   = ex::connect(std::move(snd1),
+                          expect_value_receiver{3.1415});  // NOLINT(modernize-use-std-numbers)
     ex::start(op);
   }
 
-  TEST_CASE("when_all returning two values can we waited on", "[adaptors][when_all]") {
+  TEST_CASE("when_all returning two values can we waited on", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all(ex::just(2), ex::just(3));
     wait_for_value(std::move(snd), 2, 3);
   }
 
-  TEST_CASE("when_all with 5 senders", "[adaptors][when_all]") {
+  TEST_CASE("when_all with 5 senders", "[adaptors][when_all]")
+  {
     ex::sender auto snd =
       ex::when_all(ex::just(2), ex::just(3), ex::just(5), ex::just(7), ex::just(11));
     wait_for_value(std::move(snd), 2, 3, 5, 7, 11);
   }
 
-  TEST_CASE("when_all with 8 senders", "[adaptors][when_all]") {
+  TEST_CASE("when_all with 8 senders", "[adaptors][when_all]")
+  {
     // 8 senders is the boundary case for the optimized tuple specializations
-    ex::sender auto snd = ex::when_all(
-      ex::just(2),
-      ex::just(3),
-      ex::just(5),
-      ex::just(7),
-      ex::just(11),
-      ex::just(13),
-      ex::just(17),
-      ex::just(19));
+    ex::sender auto snd = ex::when_all(ex::just(2),
+                                       ex::just(3),
+                                       ex::just(5),
+                                       ex::just(7),
+                                       ex::just(11),
+                                       ex::just(13),
+                                       ex::just(17),
+                                       ex::just(19));
     wait_for_value(std::move(snd), 2, 3, 5, 7, 11, 13, 17, 19);
   }
 
-  TEST_CASE("when_all with 10 senders", "[adaptors][when_all]") {
+  TEST_CASE("when_all with 10 senders", "[adaptors][when_all]")
+  {
     // 10 senders uses the generic tuple with __box storage
-    ex::sender auto snd = ex::when_all(
-      ex::just(2),
-      ex::just(3),
-      ex::just(5),
-      ex::just(7),
-      ex::just(11),
-      ex::just(13),
-      ex::just(17),
-      ex::just(19),
-      ex::just(23),
-      ex::just(29));
+    ex::sender auto snd = ex::when_all(ex::just(2),
+                                       ex::just(3),
+                                       ex::just(5),
+                                       ex::just(7),
+                                       ex::just(11),
+                                       ex::just(13),
+                                       ex::just(17),
+                                       ex::just(19),
+                                       ex::just(23),
+                                       ex::just(29));
     wait_for_value(std::move(snd), 2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
   }
 
-  TEST_CASE("when_all with just one sender", "[adaptors][when_all]") {
+  TEST_CASE("when_all with just one sender", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all(ex::just(2));
     wait_for_value(std::move(snd), 2);
   }
 
-  TEST_CASE("when_all with move-only types", "[adaptors][when_all]") {
+  TEST_CASE("when_all with move-only types", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all(ex::just(movable(2)));
     wait_for_value(std::move(snd), movable(2));
   }
 
-  TEST_CASE("when_all with no senders", "[adaptors][when_all]") {
+  TEST_CASE("when_all with no senders", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all();
     wait_for_value(std::move(snd));
   }
 
-  TEST_CASE("when_all when one sender sends void", "[adaptors][when_all]") {
+  TEST_CASE("when_all when one sender sends void", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all(ex::just(2), ex::just());
     wait_for_value(std::move(snd), 2);
   }
 
-  TEST_CASE("when_all_with_variant basic example", "[adaptors][when_all]") {
+  TEST_CASE("when_all_with_variant basic example", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all_with_variant(ex::just(2), ex::just(3.14));
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int>>{2}, std::variant<std::tuple<double>>{3.14});
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int>>{2},
+                   std::variant<std::tuple<double>>{3.14});
   }
 
-  TEST_CASE("when_all_with_variant with same type", "[adaptors][when_all]") {
+  TEST_CASE("when_all_with_variant with same type", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all_with_variant(ex::just(2), ex::just(3));
-    wait_for_value(
-      std::move(snd), std::variant<std::tuple<int>>{2}, std::variant<std::tuple<int>>{3});
+    wait_for_value(std::move(snd),
+                   std::variant<std::tuple<int>>{2},
+                   std::variant<std::tuple<int>>{3});
   }
 
-  TEST_CASE("when_all_with_variant with no senders", "[adaptors][when_all]") {
+  TEST_CASE("when_all_with_variant with no senders", "[adaptors][when_all]")
+  {
     ex::sender auto snd = ex::when_all_with_variant();
     wait_for_value(std::move(snd));
   }
 
-  TEST_CASE("when_all completes when children complete", "[adaptors][when_all]") {
+  TEST_CASE("when_all completes when children complete", "[adaptors][when_all]")
+  {
     impulse_scheduler sched;
-    bool called{false};
-    ex::sender auto snd = ex::when_all(
-                            ex::just(11) | ex::continues_on(sched),
-                            ex::just(13) | ex::continues_on(sched),
-                            ex::just(17))
-                        | ex::continues_on(sched) | ex::then([&](int a, int b, int c) {
-                            called = true;
-                            return a + b + c;
-                          });
+    bool              called{false};
+    ex::sender auto   snd = ex::when_all(ex::just(11) | ex::continues_on(sched),
+                                       ex::just(13) | ex::continues_on(sched),
+                                       ex::just(17))
+                        | ex::continues_on(sched)
+                        | ex::then(
+                            [&](int a, int b, int c)
+                            {
+                              called = true;
+                              return a + b + c;
+                            });
     auto op = ex::connect(std::move(snd), expect_value_receiver{41});
     ex::start(op);
     // The when_all scheduler will complete only after 3 impulses
@@ -153,16 +171,18 @@ namespace {
     CHECK(called);
   }
 
-  TEST_CASE("when_all can be used with just_*", "[adaptors][when_all]") {
-    ex::sender auto snd =
-      ex::when_all(ex::just(2), ex::just_error(std::exception_ptr{}), ex::just_stopped());
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+  TEST_CASE("when_all can be used with just_*", "[adaptors][when_all]")
+  {
+    ex::sender auto snd = ex::when_all(ex::just(2),
+                                       ex::just_error(std::exception_ptr{}),
+                                       ex::just_stopped());
+    auto            op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE(
-    "when_all terminates with error if one child terminates with error",
-    "[adaptors][when_all]") {
+  TEST_CASE("when_all terminates with error if one child terminates with error",
+            "[adaptors][when_all]")
+  {
     error_scheduler sched;
     ex::sender auto snd = ex::when_all(ex::just(2), ex::just(5), ex::just(7))
                         | ex::continues_on(sched);
@@ -170,71 +190,80 @@ namespace {
     ex::start(op);
   }
 
-  TEST_CASE("when_all terminates with stopped if one child is cancelled", "[adaptors][when_all]") {
+  TEST_CASE("when_all terminates with stopped if one child is cancelled", "[adaptors][when_all]")
+  {
     stopped_scheduler sched;
-    ex::sender auto snd = ex::when_all(ex::just(2), ex::just(5), ex::just(7))
+    ex::sender auto   snd = ex::when_all(ex::just(2), ex::just(5), ex::just(7))
                         | ex::continues_on(sched);
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
   }
 
-  TEST_CASE("when_all cancels remaining children if error is detected", "[adaptors][when_all]") {
+  TEST_CASE("when_all cancels remaining children if error is detected", "[adaptors][when_all]")
+  {
     impulse_scheduler sched;
-    error_scheduler err_sched;
-    bool called1{false};
-    bool called3{false};
-    bool cancelled{false};
-    ex::sender auto snd = ex::when_all(
-      ex::starts_on(sched, ex::just()) | ex::then([&] { called1 = true; }),
-      ex::starts_on(sched, ex::just(5)) | ex::continues_on(err_sched),
-      ex::starts_on(sched, ex::just()) | ex::then([&] { called3 = true; }) | ex::let_stopped([&] {
-        cancelled = true;
-        return ex::just();
-      }));
+    error_scheduler   err_sched;
+    bool              called1{false};
+    bool              called3{false};
+    bool              cancelled{false};
+    ex::sender auto   snd =
+      ex::when_all(ex::starts_on(sched, ex::just()) | ex::then([&] { called1 = true; }),
+                   ex::starts_on(sched, ex::just(5)) | ex::continues_on(err_sched),
+                   ex::starts_on(sched, ex::just()) | ex::then([&] { called3 = true; })
+                     | ex::let_stopped(
+                       [&]
+                       {
+                         cancelled = true;
+                         return ex::just();
+                       }));
     auto op = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     // The first child will complete; the third one will be cancelled
     CHECK_FALSE(called1);
     CHECK_FALSE(called3);
-    sched.start_next(); // start the first child
+    sched.start_next();  // start the first child
     CHECK(called1);
-    sched.start_next(); // start the second child; this will generate an error
+    sched.start_next();  // start the second child; this will generate an error
     CHECK_FALSE(called3);
-    sched.start_next(); // start the third child
+    sched.start_next();  // start the third child
     CHECK_FALSE(called3);
     CHECK(cancelled);
   }
 
-  TEST_CASE("when_all cancels remaining children if cancel is detected", "[adaptors][when_all]") {
+  TEST_CASE("when_all cancels remaining children if cancel is detected", "[adaptors][when_all]")
+  {
     stopped_scheduler stopped_sched;
     impulse_scheduler sched;
-    bool called1{false};
-    bool called3{false};
-    bool cancelled{false};
-    ex::sender auto snd = ex::when_all(
-      ex::starts_on(sched, ex::just()) | ex::then([&] { called1 = true; }),
-      ex::starts_on(sched, ex::just(5)) | ex::continues_on(stopped_sched),
-      ex::starts_on(sched, ex::just()) | ex::then([&] { called3 = true; }) | ex::let_stopped([&] {
-        cancelled = true;
-        return ex::just();
-      }));
+    bool              called1{false};
+    bool              called3{false};
+    bool              cancelled{false};
+    ex::sender auto   snd =
+      ex::when_all(ex::starts_on(sched, ex::just()) | ex::then([&] { called1 = true; }),
+                   ex::starts_on(sched, ex::just(5)) | ex::continues_on(stopped_sched),
+                   ex::starts_on(sched, ex::just()) | ex::then([&] { called3 = true; })
+                     | ex::let_stopped(
+                       [&]
+                       {
+                         cancelled = true;
+                         return ex::just();
+                       }));
     auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     // The first child will complete; the third one will be cancelled
     CHECK_FALSE(called1);
     CHECK_FALSE(called3);
-    sched.start_next(); // start the first child
+    sched.start_next();  // start the first child
     CHECK(called1);
-    sched.start_next(); // start the second child; this will call set_stopped
+    sched.start_next();  // start the second child; this will call set_stopped
     CHECK_FALSE(called3);
-    sched.start_next(); // start the third child
+    sched.start_next();  // start the third child
     CHECK_FALSE(called3);
     CHECK(cancelled);
   }
 
-  TEST_CASE(
-    "when_all has the values_type based on the children, decayed and as rvalue references",
-    "[adaptors][when_all]") {
+  TEST_CASE("when_all has the values_type based on the children, decayed and as rvalue references",
+            "[adaptors][when_all]")
+  {
     check_val_types<ex::__mset<pack<int>>>(ex::when_all(ex::just(13)));
     check_val_types<ex::__mset<pack<double>>>(ex::when_all(ex::just(3.14)));
     check_val_types<ex::__mset<pack<int, double>>>(ex::when_all(ex::just(3, 0.14)));
@@ -254,7 +283,8 @@ namespace {
       ex::when_all(exec::split(ex::just(3)), exec::split(ex::just(0.14))));
   }
 
-  TEST_CASE("when_all has the error_types based on the children", "[adaptors][when_all]") {
+  TEST_CASE("when_all has the error_types based on the children", "[adaptors][when_all]")
+  {
     check_err_types<ex::__mset<int>>(ex::when_all(ex::just_error(13)));
     check_err_types<ex::__mset<double>>(ex::when_all(ex::just_error(3.14)));
 
@@ -268,9 +298,9 @@ namespace {
       ex::when_all(ex::just(13), ex::just_error(std::exception_ptr{}), ex::just_stopped()));
   }
 
-  TEST_CASE(
-    "when_all has sends_stopped == true if and only if at least one child sends stopped",
-    "[adaptors][when_all]") {
+  TEST_CASE("when_all has sends_stopped == true if and only if at least one child sends stopped",
+            "[adaptors][when_all]")
+  {
     check_sends_stopped<false>(ex::when_all(ex::just(13)));
     check_sends_stopped<false>(ex::when_all(ex::just_error(-1)));
     check_sends_stopped<true>(ex::when_all(ex::just_stopped()));
@@ -279,57 +309,67 @@ namespace {
     check_sends_stopped<true>(ex::when_all(ex::just(3), ex::just_error(-1), ex::just_stopped()));
   }
 
-  struct test_domain1 { };
+  struct test_domain1
+  {};
 
-  struct test_domain2 : test_domain1 { };
+  struct test_domain2 : test_domain1
+  {};
 
-  TEST_CASE("when_all propagates domain from children", "[adaptors][when_all]") {
+  TEST_CASE("when_all propagates domain from children", "[adaptors][when_all]")
+  {
     basic_inline_scheduler<test_domain1> sched1;
     basic_inline_scheduler<test_domain2> sched2;
 
-    auto snd =
-      ex::when_all(ex::starts_on(sched1, ex::just(13)), ex::starts_on(sched2, ex::just(3.14)));
-    auto env = ex::get_env(snd);
+    auto snd    = ex::when_all(ex::starts_on(sched1, ex::just(13)),
+                            ex::starts_on(sched2, ex::just(3.14)));
+    auto env    = ex::get_env(snd);
     auto domain = ex::get_completion_domain<ex::set_value_t>(env, ex::env<>{});
     STATIC_REQUIRE(std::same_as<decltype(domain), test_domain1>);
   }
 
-  namespace {
-    enum customize : std::size_t {
+  namespace
+  {
+    enum customize : std::size_t
+    {
       early,
       late,
       none
     };
 
     template <class Tag, customize C, auto Fun>
-    struct basic_domain {
+    struct basic_domain
+    {
       template <ex::sender_expr_for<Tag> Sender, class... Env>
         requires(sizeof...(Env) == C)
-      auto transform_sender(STDEXEC::set_value_t, Sender&&, Env&&...) const {
+      auto transform_sender(STDEXEC::set_value_t, Sender&&, Env&&...) const
+      {
         return Fun();
       }
     };
-  } // anonymous namespace
+  }  // anonymous namespace
 
-  TEST_CASE("when_all works with custom domain", "[adaptors][when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("when_all works with custom domain", "[adaptors][when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::when_all_t, customize::none, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::when_all_t, customize::none, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd = ex::when_all(
-        ex::just(3) | ex::continues_on(scheduler()),
-        ex::just(0.1415) | ex::continues_on(scheduler()));
+      auto snd = ex::when_all(ex::just(3) | ex::continues_on(scheduler()),
+                              ex::just(0.1415) | ex::continues_on(scheduler()));
       static_assert(ex::sender_expr_for<decltype(snd), ex::when_all_t>);
       [[maybe_unused]]
       domain dom = ex::get_completion_domain<ex::set_value_t>(ex::get_env(snd), ex::env{});
     }
 
-    SECTION("late customization") {
-      using domain = basic_domain<ex::when_all_t, customize::late, hello>;
+    SECTION("late customization")
+    {
+      using domain    = basic_domain<ex::when_all_t, customize::late, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
       auto snd = ex::starts_on(scheduler(), ex::when_all(ex::just(3), ex::just(0.1415)));
@@ -337,81 +377,82 @@ namespace {
     }
   }
 
-  TEST_CASE("when_all_with_variant works with custom domain", "[adaptors][when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("when_all_with_variant works with custom domain", "[adaptors][when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::when_all_with_variant_t, customize::none, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::when_all_with_variant_t, customize::none, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd = ex::when_all_with_variant(
-        ex::just(3) | ex::continues_on(scheduler()),
-        ex::just(0.1415) | ex::continues_on(scheduler()));
+      auto snd = ex::when_all_with_variant(ex::just(3) | ex::continues_on(scheduler()),
+                                           ex::just(0.1415) | ex::continues_on(scheduler()));
       static_assert(ex::sender_expr_for<decltype(snd), ex::when_all_with_variant_t>);
       [[maybe_unused]]
       domain dom = ex::get_completion_domain<ex::set_value_t>(ex::get_env(snd), ex::env{});
     }
 
-    SECTION("late customization") {
-      using domain = basic_domain<ex::when_all_with_variant_t, customize::late, hello>;
+    SECTION("late customization")
+    {
+      using domain    = basic_domain<ex::when_all_with_variant_t, customize::late, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd =
-        ex::starts_on(scheduler(), ex::when_all_with_variant(ex::just(3), ex::just(0.1415)));
+      auto snd = ex::starts_on(scheduler(),
+                               ex::when_all_with_variant(ex::just(3), ex::just(0.1415)));
       wait_for_value(std::move(snd), std::string{"hello world"});
     }
   }
 
-  TEST_CASE("when_all_with_variant finds when_all customizations", "[adaptors][when_all]") {
-    constexpr auto hello = [] {
+  TEST_CASE("when_all_with_variant finds when_all customizations", "[adaptors][when_all]")
+  {
+    constexpr auto hello = []
+    {
       return ex::just(std::string{"hello world"});
     };
 
-    SECTION("sender has correct domain") {
-      using domain = basic_domain<ex::when_all_t, customize::none, hello>;
+    SECTION("sender has correct domain")
+    {
+      using domain    = basic_domain<ex::when_all_t, customize::none, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd = ex::when_all_with_variant(
-        ex::just(3) | ex::continues_on(scheduler()),
-        ex::just(0.1415) | ex::continues_on(scheduler()));
+      auto snd = ex::when_all_with_variant(ex::just(3) | ex::continues_on(scheduler()),
+                                           ex::just(0.1415) | ex::continues_on(scheduler()));
       static_assert(ex::sender_expr_for<decltype(snd), ex::when_all_with_variant_t>);
       [[maybe_unused]]
       domain dom = ex::get_completion_domain<ex::set_value_t>(ex::get_env(snd), ex::env{});
     }
 
-    SECTION("late customization") {
-      using domain = basic_domain<ex::when_all_t, customize::late, hello>;
+    SECTION("late customization")
+    {
+      using domain    = basic_domain<ex::when_all_t, customize::late, hello>;
       using scheduler = basic_inline_scheduler<domain>;
 
-      auto snd =
-        ex::starts_on(scheduler(), ex::when_all_with_variant(ex::just(3), ex::just(0.1415)));
+      auto snd = ex::starts_on(scheduler(),
+                               ex::when_all_with_variant(ex::just(3), ex::just(0.1415)));
       wait_for_value(std::move(snd), std::string{"hello world"});
     }
   }
 
-  TEST_CASE("when_all defers stop handling to its children", "[adaptors][when_all]") {
+  TEST_CASE("when_all defers stop handling to its children", "[adaptors][when_all]")
+  {
     ex::inplace_stop_source source;
     source.request_stop();
     auto snd = ex::when_all(ex::just(), ex::just());
-    static_assert(set_equivalent<
-                  ex::completion_signatures_of_t<decltype(snd), ex::env<>>,
-                  ex::completion_signatures<ex::set_value_t()>
-    >);
+    static_assert(set_equivalent<ex::completion_signatures_of_t<decltype(snd), ex::env<>>,
+                                 ex::completion_signatures<ex::set_value_t()>>);
     auto env = ex::prop(ex::get_stop_token, source.get_token());
-    static_assert(set_equivalent<
-                  ex::completion_signatures_of_t<decltype(snd), decltype(env)>,
-                  ex::completion_signatures<ex::set_value_t()>
-    >);
+    static_assert(set_equivalent<ex::completion_signatures_of_t<decltype(snd), decltype(env)>,
+                                 ex::completion_signatures<ex::set_value_t()>>);
     auto op = ex::connect(snd, expect_void_receiver(env));
     ex::start(op);
   }
 
-
-  TEST_CASE(
-    "when_all handles stop requests from the environment correctly",
-    "[adaptors][when_all") {
+  TEST_CASE("when_all handles stop requests from the environment correctly", "[adaptors][when_all")
+  {
     auto snd = ex::when_all(completes_if(false), completes_if(false));
 
     exec::async_scope scope;
@@ -419,4 +460,4 @@ namespace {
     scope.request_stop();
     ex::sync_wait(scope.on_empty());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/adaptors/test_write_env.cpp b/test/stdexec/algos/adaptors/test_write_env.cpp
index afaa40358..c0dfcf4fd 100644
--- a/test/stdexec/algos/adaptors/test_write_env.cpp
+++ b/test/stdexec/algos/adaptors/test_write_env.cpp
@@ -24,45 +24,48 @@
 #include <stdexec/execution.hpp>
 #include <test_common/receivers.hpp>
 
-namespace {
+namespace
+{
 
   template <typename T>
-  struct receiver : expect_void_receiver<> {
+  struct receiver : expect_void_receiver<>
+  {
     [[nodiscard]]
-    constexpr ::STDEXEC::env<> get_env() const noexcept {
+    constexpr ::STDEXEC::env<> get_env() const noexcept
+    {
       return state_->get_env();
     }
     T* state_;
   };
 
-  struct state {
+  struct state
+  {
     [[nodiscard]]
-    constexpr ::STDEXEC::env<> get_env() const noexcept {
+    constexpr ::STDEXEC::env<> get_env() const noexcept
+    {
       return {};
     }
   };
 
-  static_assert(!std::is_same_v<
-                void,
-                decltype(::STDEXEC::connect(
-                  ::STDEXEC::just()
-                    | ::STDEXEC::write_env(
-                      ::STDEXEC::prop{
-                        ::STDEXEC::get_stop_token,
-                        std::declval<::STDEXEC::inplace_stop_source&>().get_token()}),
-                  receiver<state>{{}, nullptr}))
-  >);
+  static_assert(!std::is_same_v<void,
+                                decltype(::STDEXEC::connect(
+                                  ::STDEXEC::just()
+                                    | ::STDEXEC::write_env(::STDEXEC::prop{
+                                      ::STDEXEC::get_stop_token,
+                                      std::declval<::STDEXEC::inplace_stop_source&>().get_token()}),
+                                  receiver<state>{{}, nullptr}))>);
 
-  TEST_CASE(
-    "write_env works when the actual environment is sourced from a type which was initially "
-    "incomplete but has since been completed",
-    "[adaptors][write_env]") {
+  TEST_CASE("write_env works when the actual environment is sourced from a type which was "
+            "initially "
+            "incomplete but has since been completed",
+            "[adaptors][write_env]")
+  {
     ::STDEXEC::inplace_stop_source source;
-    state s;
-    auto op = ::STDEXEC::connect(
-      ::STDEXEC::just()
-        | ::STDEXEC::write_env(::STDEXEC::prop{::STDEXEC::get_stop_token, source.get_token()}),
-      receiver<state>{{}, &s});
+    state                          s;
+    auto                           op = ::STDEXEC::connect(::STDEXEC::just()
+                                   | ::STDEXEC::write_env(::STDEXEC::prop{::STDEXEC::get_stop_token,
+                                                                          source.get_token()}),
+                                 receiver<state>{{}, &s});
     ::STDEXEC::start(op);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/consumers/test_spawn.cpp b/test/stdexec/algos/consumers/test_spawn.cpp
index aebf0c6db..7cf0b9f7b 100644
--- a/test/stdexec/algos/consumers/test_spawn.cpp
+++ b/test/stdexec/algos/consumers/test_spawn.cpp
@@ -17,8 +17,8 @@
 
 #include <catch2/catch.hpp>
 #include <stdexec/execution.hpp>
-#include <test_common/scope_tokens.hpp>
 #include <test_common/scope_helpers.hpp>
+#include <test_common/scope_tokens.hpp>
 
 #include <array>
 #include <memory_resource>
@@ -26,59 +26,67 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("Trivial spawns compile", "[consumers][spawn]") {
+namespace
+{
+  TEST_CASE("Trivial spawns compile", "[consumers][spawn]")
+  {
     ex::spawn(ex::just(), null_token{});
     ex::spawn(ex::just_stopped(), null_token{});
   }
 
-  TEST_CASE("spawn doesn't leak", "[consumers][spawn]") {
-    counting_resource rsc;
+  TEST_CASE("spawn doesn't leak", "[consumers][spawn]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
 
-    ex::spawn(
-      ex::read_env(ex::get_allocator) | ex::then([&](auto&& envAlloc) noexcept {
-        // check that the allocator provided to spawn is in our environment
-        REQUIRE(alloc == envAlloc);
-        // check that we actually allocated something to run this op
-        REQUIRE(rsc.allocated() > 0);
-      }),
-      null_token{},
-      ex::prop(ex::get_allocator, alloc));
+    ex::spawn(ex::read_env(ex::get_allocator)
+                | ex::then(
+                  [&](auto&& envAlloc) noexcept
+                  {
+                    // check that the allocator provided to spawn is in our environment
+                    REQUIRE(alloc == envAlloc);
+                    // check that we actually allocated something to run this op
+                    REQUIRE(rsc.allocated() > 0);
+                  }),
+              null_token{},
+              ex::prop(ex::get_allocator, alloc));
 
     REQUIRE(rsc.allocated() == 0);
   }
 
-  TEST_CASE("spawn reads an allocator from the sender's environment", "[consumers][spawn]") {
-    counting_resource rsc;
+  TEST_CASE("spawn reads an allocator from the sender's environment", "[consumers][spawn]")
+  {
+    counting_resource                 rsc;
     std::pmr::polymorphic_allocator<> alloc(&rsc);
 
     scope_with_alloc scope{alloc};
 
     REQUIRE(rsc.allocated() == 0);
 
-    ex::spawn(
-      ex::read_env(ex::get_allocator) | ex::then([&](auto&& envAlloc) noexcept {
-        // we should've pulled the scope's allocator into our environment
-        REQUIRE(alloc == envAlloc);
+    ex::spawn(ex::read_env(ex::get_allocator)
+                | ex::then(
+                  [&](auto&& envAlloc) noexcept
+                  {
+                    // we should've pulled the scope's allocator into our environment
+                    REQUIRE(alloc == envAlloc);
 
-        // we should've allocated some memory for this operation
-        REQUIRE(rsc.allocated() > 0);
-      }),
-      scope.get_token());
+                    // we should've allocated some memory for this operation
+                    REQUIRE(rsc.allocated() > 0);
+                  }),
+              scope.get_token());
 
     REQUIRE(rsc.allocated() == 0);
   }
 
-  TEST_CASE(
-    "The allocator provided directly to spawn overrides the allocator in the sender's environment",
-    "[consumers][spawn]") {
-
+  TEST_CASE("The allocator provided directly to spawn overrides the allocator in the sender's "
+            "environment",
+            "[consumers][spawn]")
+  {
     counting_resource rsc1;
 
-    std::array<std::byte, 256> buffer{};
+    std::array<std::byte, 256>          buffer{};
     std::pmr::monotonic_buffer_resource bumpAlloc(buffer.data(), buffer.size());
 
     counting_resource rsc2(bumpAlloc);
@@ -93,32 +101,37 @@ namespace {
     REQUIRE(rsc1.allocated() == 0);
     REQUIRE(rsc2.allocated() == 0);
 
-    ex::spawn(
-      ex::read_env(ex::get_allocator) | ex::then([&](auto& envAlloc) noexcept {
-        // the allocator in the environment should be the one provided to spawn
-        // as an explicit argument and not the one provided by the scope
-        REQUIRE(alloc1 != envAlloc);
-        REQUIRE(alloc2 == envAlloc);
-
-        // we should have allocated some memory for the op from rsc2 but not from rsc
-        REQUIRE(rsc1.allocated() == 0);
-        REQUIRE(rsc2.allocated() > 0);
-      }),
-      scope.get_token(),
-      ex::prop(ex::get_allocator, alloc2));
+    ex::spawn(ex::read_env(ex::get_allocator)
+                | ex::then(
+                  [&](auto& envAlloc) noexcept
+                  {
+                    // the allocator in the environment should be the one provided to spawn
+                    // as an explicit argument and not the one provided by the scope
+                    REQUIRE(alloc1 != envAlloc);
+                    REQUIRE(alloc2 == envAlloc);
+
+                    // we should have allocated some memory for the op from rsc2 but not from rsc
+                    REQUIRE(rsc1.allocated() == 0);
+                    REQUIRE(rsc2.allocated() > 0);
+                  }),
+              scope.get_token(),
+              ex::prop(ex::get_allocator, alloc2));
 
     REQUIRE(rsc1.allocated() == 0);
     REQUIRE(rsc2.allocated() == 0);
   }
 
-  TEST_CASE("spawn tolerates throwing scope tokens", "[consumers][spawn]") {
-    counting_resource rsc;
+  TEST_CASE("spawn tolerates throwing scope tokens", "[consumers][spawn]")
+  {
+    counting_resource                          rsc;
     std::pmr::polymorphic_allocator<std::byte> alloc(&rsc);
 
-    struct throwing_token : null_token {
-      const counting_resource* rsc;
+    struct throwing_token : null_token
+    {
+      counting_resource const * rsc;
 
-      assoc try_associate() const {
+      assoc try_associate() const
+      {
         REQUIRE(rsc->allocated() > 0);
         throw std::runtime_error("nope");
       }
@@ -127,9 +140,12 @@ namespace {
     REQUIRE(rsc.allocated() == 0);
 
     bool threw = false;
-    try {
+    try
+    {
       ex::spawn(ex::just(), throwing_token{{}, &rsc}, ex::prop(ex::get_allocator, alloc));
-    } catch (const std::runtime_error& e) {
+    }
+    catch (std::runtime_error const & e)
+    {
       threw = true;
       REQUIRE(std::string{"nope"} == e.what());
     }
@@ -139,39 +155,46 @@ namespace {
     REQUIRE(rsc.allocated() == 0);
   }
 
-  TEST_CASE("spawn tolerates expired scope tokens", "[consumers][spawn]") {
-    struct expired_token : null_token { // inherit the wrap method template
-      const counting_resource* rsc;
-      bool* tried;
-
-      struct assoc {
-        constexpr explicit operator bool() const noexcept {
+  TEST_CASE("spawn tolerates expired scope tokens", "[consumers][spawn]")
+  {
+    struct expired_token : null_token
+    {  // inherit the wrap method template
+      counting_resource const * rsc;
+      bool*                     tried;
+
+      struct assoc
+      {
+        constexpr explicit operator bool() const noexcept
+        {
           return false;
         }
 
-        constexpr assoc try_associate() const noexcept {
+        constexpr assoc try_associate() const noexcept
+        {
           return {};
         }
       };
 
-      assoc try_associate() const {
+      assoc try_associate() const
+      {
         REQUIRE(rsc->allocated() > 0);
         *tried = true;
         return {};
       }
     };
 
-    counting_resource rsc;
+    counting_resource                          rsc;
     std::pmr::polymorphic_allocator<std::byte> alloc(&rsc);
 
     REQUIRE(rsc.allocated() == 0);
 
     bool triedToAssociate = false;
 
-    ex::spawn(
-      ex::just(), expired_token{{}, &rsc, &triedToAssociate}, ex::prop(ex::get_allocator, alloc));
+    ex::spawn(ex::just(),
+              expired_token{{}, &rsc, &triedToAssociate},
+              ex::prop(ex::get_allocator, alloc));
 
     REQUIRE(rsc.allocated() == 0);
     REQUIRE(triedToAssociate);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/consumers/test_sync_wait.cpp b/test/stdexec/algos/consumers/test_sync_wait.cpp
index af5391060..e6c569407 100644
--- a/test/stdexec/algos/consumers/test_sync_wait.cpp
+++ b/test/stdexec/algos/consumers/test_sync_wait.cpp
@@ -30,20 +30,24 @@ namespace ex = STDEXEC;
 
 using namespace std::chrono_literals;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("sync_wait simple test", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait simple test", "[consumers][sync_wait]")
+  {
     std::optional<std::tuple<int>> res = ex::sync_wait(ex::just(49));
     CHECK(res.has_value());
     CHECK(std::get<0>(res.value()) == 49);
   }
 
-  TEST_CASE("sync_wait can wait on void values", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait can wait on void values", "[consumers][sync_wait]")
+  {
     std::optional<std::tuple<>> res = ex::sync_wait(ex::just());
     CHECK(res.has_value());
   }
 
-  TEST_CASE("sync_wait can wait on senders sending value packs", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait can wait on senders sending value packs", "[consumers][sync_wait]")
+  {
     std::optional<std::tuple<int, double>> res = ex::sync_wait(ex::just(3, 0.1415));
     CHECK(res.has_value());
     CHECK(std::get<0>(res.value()) == 3);
@@ -51,79 +55,104 @@ namespace {
   }
 
 #if !STDEXEC_NO_STD_EXCEPTIONS()
-  TEST_CASE("sync_wait rethrows received exception", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait rethrows received exception", "[consumers][sync_wait]")
+  {
     // Generate an exception pointer object
     std::exception_ptr eptr;
-    try {
+    try
+    {
       throw std::logic_error("err");
-    } catch (...) {
+    }
+    catch (...)
+    {
       eptr = std::current_exception();
     }
 
     // Ensure that ex::sync_wait will rethrow the error
-    try {
+    try
+    {
       error_scheduler<std::exception_ptr> sched{eptr};
       ex::sync_wait(ex::just(19) | ex::continues_on(sched));
       FAIL("exception not thrown?");
-    } catch (const std::logic_error& e) {
+    }
+    catch (std::logic_error const & e)
+    {
       CHECK(std::string{e.what()} == "err");
-    } catch (...) {
+    }
+    catch (...)
+    {
       FAIL("invalid exception received");
     }
   }
 
-  TEST_CASE("sync_wait handling error_code errors", "[consumers][sync_wait]") {
-    try {
+  TEST_CASE("sync_wait handling error_code errors", "[consumers][sync_wait]")
+  {
+    try
+    {
       error_scheduler<std::error_code> sched{
         std::make_error_code(std::errc::argument_out_of_domain)};
       ex::sender auto snd = ex::just(19) | ex::continues_on(sched);
       static_assert(std::invocable<ex::sync_wait_t, decltype(snd)>);
-      ex::sync_wait(std::move(snd)); // doesn't work
+      ex::sync_wait(std::move(snd));  // doesn't work
       FAIL("expecting exception to be thrown");
-    } catch (const std::system_error& e) {
+    }
+    catch (std::system_error const & e)
+    {
       CHECK(e.code() == std::errc::argument_out_of_domain);
-    } catch (...) {
+    }
+    catch (...)
+    {
       FAIL("expecting std::system_error exception to be thrown");
     }
   }
 
-  TEST_CASE("sync_wait handling non-exception errors", "[consumers][sync_wait]") {
-    try {
+  TEST_CASE("sync_wait handling non-exception errors", "[consumers][sync_wait]")
+  {
+    try
+    {
       error_scheduler<std::string> sched{std::string{"err"}};
-      ex::sender auto snd = ex::just(19) | ex::continues_on(sched);
+      ex::sender auto              snd = ex::just(19) | ex::continues_on(sched);
       static_assert(std::invocable<ex::sync_wait_t, decltype(snd)>);
-      ex::sync_wait(std::move(snd)); // doesn't work
+      ex::sync_wait(std::move(snd));  // doesn't work
       FAIL("expecting exception to be thrown");
-    } catch (const std::string& e) {
+    }
+    catch (std::string const & e)
+    {
       CHECK(e == "err");
-    } catch (...) {
+    }
+    catch (...)
+    {
       FAIL("expecting std::string exception to be thrown");
     }
   }
-#endif // !STDEXEC_NO_STD_EXCEPTIONS()
+#endif  // !STDEXEC_NO_STD_EXCEPTIONS()
 
-  TEST_CASE("sync_wait returns empty optional on cancellation", "[consumers][sync_wait]") {
-    stopped_scheduler sched;
+  TEST_CASE("sync_wait returns empty optional on cancellation", "[consumers][sync_wait]")
+  {
+    stopped_scheduler              sched;
     std::optional<std::tuple<int>> res = ex::sync_wait(ex::just(19) | ex::continues_on(sched));
     CHECK_FALSE(res.has_value());
   }
 
   template <class T>
-  auto always(T t) {
-    return [t](auto&&...) mutable {
+  auto always(T t)
+  {
+    return [t](auto&&...) mutable
+    {
       return std::move(t);
     };
   }
 
-  TEST_CASE("sync_wait doesn't accept multi-variant senders", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait doesn't accept multi-variant senders", "[consumers][sync_wait]")
+  {
     ex::sender auto snd = fallible_just{13} | ex::let_error(always(ex::just(std::string{"err"})));
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(snd));
     // static_assert(!std::invocable<ex::sync_wait_t, decltype(snd)>);
   }
 
-  TEST_CASE(
-    "sync_wait_with_variant accepts multi-variant senders",
-    "[consumers][sync_wait_with_variant]") {
+  TEST_CASE("sync_wait_with_variant accepts multi-variant senders",
+            "[consumers][sync_wait_with_variant]")
+  {
     ex::sender auto snd = fallible_just{13} | ex::let_error(always(ex::just(std::string{"err"})));
     check_val_types<ex::__mset<pack<int>, pack<std::string>>>(std::move(snd));
     static_assert(std::invocable<ex::sync_wait_with_variant_t, decltype(snd)>);
@@ -135,9 +164,9 @@ namespace {
     CHECK_TUPLE(std::get<0>(std::get<0>(res.value())) == std::make_tuple(13));
   }
 
-  TEST_CASE(
-    "sync_wait_with_variant accepts single-value senders",
-    "[consumers][sync_wait_with_variant]") {
+  TEST_CASE("sync_wait_with_variant accepts single-value senders",
+            "[consumers][sync_wait_with_variant]")
+  {
     ex::sender auto snd = ex::just(13);
     check_val_types<ex::__mset<pack<int>>>(snd);
     static_assert(std::invocable<ex::sync_wait_with_variant_t, decltype(snd)>);
@@ -148,22 +177,25 @@ namespace {
     CHECK_TUPLE(std::get<0>(std::get<0>(res.value())) == std::make_tuple(13));
   }
 
-  TEST_CASE("sync_wait works if signaled from a different thread", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait works if signaled from a different thread", "[consumers][sync_wait]")
+  {
     std::atomic<bool> thread_started{false};
     std::atomic<bool> thread_stopped{false};
     impulse_scheduler sched;
 
     // Thread that calls `ex::sync_wait`
-    auto waiting_thread = std::thread{[&] {
-      thread_started.store(true);
-
-      // Wait for a result that is triggered by the impulse scheduler
-      std::optional<std::tuple<int>> res = ex::sync_wait(ex::just(49) | ex::continues_on(sched));
-      CHECK(res.has_value());
-      CHECK(std::get<0>(res.value()) == 49);
-
-      thread_stopped.store(true);
-    }};
+    auto waiting_thread = std::thread{
+      [&]
+      {
+        thread_started.store(true);
+
+        // Wait for a result that is triggered by the impulse scheduler
+        std::optional<std::tuple<int>> res = ex::sync_wait(ex::just(49) | ex::continues_on(sched));
+        CHECK(res.has_value());
+        CHECK(std::get<0>(res.value()) == 49);
+
+        thread_stopped.store(true);
+      }};
     // Wait for the thread to start (poor-man's sync)
     for (int i = 0; i < 10'000 && !thread_started.load(); i++)
       std::this_thread::sleep_for(100us);
@@ -177,19 +209,19 @@ namespace {
     CHECK(thread_stopped.load());
   }
 
-  TEST_CASE(
-    "sync_wait can wait on operations happening on different threads",
-    "[consumers][sync_wait]") {
-    auto square = [](int x) {
+  TEST_CASE("sync_wait can wait on operations happening on different threads",
+            "[consumers][sync_wait]")
+  {
+    auto square = [](int x)
+    {
       return x * x;
     };
 
     exec::static_thread_pool pool{3};
-    ex::scheduler auto sched = pool.get_scheduler();
-    ex::sender auto snd = ex::when_all(
-      ex::just(2) | ex::continues_on(sched) | ex::then(square),
-      ex::just(3) | ex::continues_on(sched) | ex::then(square),
-      ex::just(5) | ex::continues_on(sched) | ex::then(square));
+    ex::scheduler auto       sched = pool.get_scheduler();
+    ex::sender auto snd = ex::when_all(ex::just(2) | ex::continues_on(sched) | ex::then(square),
+                                       ex::just(3) | ex::continues_on(sched) | ex::then(square),
+                                       ex::just(5) | ex::continues_on(sched) | ex::then(square));
     std::optional<std::tuple<int, int, int>> res = ex::sync_wait(std::move(snd));
     CHECK(res.has_value());
     CHECK(std::get<0>(res.value()) == 4);
@@ -199,30 +231,32 @@ namespace {
 
   // This domain is used to customize the behavior of sync_wait and sync_wait_with_variant
   // for senders with particular completion signatures.
-  struct sync_wait_test_domain {
+  struct sync_wait_test_domain
+  {
     using single_result_t = std::optional<std::tuple<std::string>>;
-    using multi_result_t = std::optional<std::variant<std::tuple<int>, std::tuple<std::string>>>;
+    using multi_result_t  = std::optional<std::variant<std::tuple<int>, std::tuple<std::string>>>;
 
     template <class Sender>
       requires std::same_as<
         ex::value_types_of_t<Sender, ex::env<>, std::type_identity_t, std::type_identity_t>,
-        std::string
-      >
-    static auto apply_sender(ex::sync_wait_t, Sender&&) -> single_result_t {
+        std::string>
+    static auto apply_sender(ex::sync_wait_t, Sender&&) -> single_result_t
+    {
       return {std::string{"ciao"}};
     }
 
     template <class Sender>
       requires ex::__mset_eq<
         ex::value_types_of_t<Sender, ex::env<>, std::type_identity_t, ex::__mmake_set>,
-        ex::__mset<std::string, int>
-      >
-    static auto apply_sender(ex::sync_wait_with_variant_t, Sender&&) -> multi_result_t {
+        ex::__mset<std::string, int>>
+    static auto apply_sender(ex::sync_wait_with_variant_t, Sender&&) -> multi_result_t
+    {
       return {std::string{"ciao_multi"}};
     }
   };
 
-  TEST_CASE("sync_wait can be customized", "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait can be customized", "[consumers][sync_wait]")
+  {
     basic_inline_scheduler<sync_wait_test_domain> sched;
 
     // The customization will return a different value
@@ -252,24 +286,23 @@ namespace {
   template <class... Ts>
   using decayed_tuple = std::tuple<std::decay_t<Ts>...>;
 
-  TEST_CASE(
-    "sync_wait spec's return type defined in terms of value_types_of_t",
-    "[consumers][sync_wait]") {
+  TEST_CASE("sync_wait spec's return type defined in terms of value_types_of_t",
+            "[consumers][sync_wait]")
+  {
     static_assert(
       std::is_same_v<
         std::tuple<>,
-        ex::value_types_of_t<decltype(ex::just()), ex::env<>, decayed_tuple, std::type_identity_t>
-      >);
+        ex::value_types_of_t<decltype(ex::just()), ex::env<>, decayed_tuple, std::type_identity_t>>);
   }
 
 #if STDEXEC_NAMESPACE_IS_WITHIN_STD()
-  TEST_CASE(
-    "std::this_thread::sync_wait is available when STDEXEC is std::execution",
-    "[consumers][sync_wait]") {
+  TEST_CASE("std::this_thread::sync_wait is available when STDEXEC is std::execution",
+            "[consumers][sync_wait]")
+  {
     std::optional<std::tuple<int>> res = std::this_thread::sync_wait(ex::just(49));
     CHECK(res.has_value());
     CHECK(std::get<0>(res.value()) == 49);
   }
 #endif
 
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_just.cpp b/test/stdexec/algos/factories/test_just.cpp
index dabd1c1d8..a68b865bc 100644
--- a/test/stdexec/algos/factories/test_just.cpp
+++ b/test/stdexec/algos/factories/test_just.cpp
@@ -25,24 +25,29 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  constexpr int test_constexpr() noexcept {
-    struct receiver {
+  constexpr int test_constexpr() noexcept
+  {
+    struct receiver
+    {
       using receiver_concept = ex::receiver_t;
-      constexpr void set_value(const int j) && noexcept {
+      constexpr void set_value(int const j) && noexcept
+      {
         i = j;
       }
       int& i;
     };
-    int i = 0;
+    int  i  = 0;
     auto op = ex::connect(ex::just(5), receiver{i});
     ex::start(op);
     return i;
   }
   static_assert(test_constexpr() == 5);
 
-  TEST_CASE("Simple test for just", "[factories][just]") {
+  TEST_CASE("Simple test for just", "[factories][just]")
+  {
     auto o1 = ex::connect(ex::just(1), expect_value_receiver(1));
     ex::start(o1);
     auto o2 = ex::connect(ex::just(2), expect_value_receiver(2));
@@ -50,24 +55,27 @@ namespace {
     auto o3 = ex::connect(ex::just(3), expect_value_receiver(3));
     ex::start(o3);
 
-    auto o4 =
-      ex::connect(ex::just(std::string("this")), expect_value_receiver(std::string("this")));
+    auto o4 = ex::connect(ex::just(std::string("this")),
+                          expect_value_receiver(std::string("this")));
     ex::start(o4);
-    auto o5 =
-      ex::connect(ex::just(std::string("that")), expect_value_receiver(std::string("that")));
+    auto o5 = ex::connect(ex::just(std::string("that")),
+                          expect_value_receiver(std::string("that")));
     ex::start(o5);
   }
 
-  TEST_CASE("just returns a sender", "[factories][just]") {
+  TEST_CASE("just returns a sender", "[factories][just]")
+  {
     using t = decltype(ex::just(1));
     static_assert(ex::sender<t>, "ex::just must return a sender");
     REQUIRE(ex::sender<t>);
     REQUIRE(ex::enable_sender<t>);
   }
 
-  TEST_CASE("just can handle multiple values", "[factories][just]") {
+  TEST_CASE("just can handle multiple values", "[factories][just]")
+  {
     bool executed{false};
-    auto f = [&](int x, double d) {
+    auto f = [&](int x, double d)
+    {
       CHECK(x == 3);
       CHECK(d == 0.14);
       executed = true;
@@ -77,7 +85,8 @@ namespace {
     CHECK(executed);
   }
 
-  TEST_CASE("value types are properly set for just", "[factories][just]") {
+  TEST_CASE("value types are properly set for just", "[factories][just]")
+  {
     check_val_types<ex::__mset<pack<int>>>(ex::just(1));
     check_val_types<ex::__mset<pack<double>>>(ex::just(3.14));
     check_val_types<ex::__mset<pack<std::string>>>(ex::just(std::string{}));
@@ -86,15 +95,18 @@ namespace {
     check_val_types<ex::__mset<pack<int, double, std::string>>>(ex::just(1, 3.14, std::string{}));
   }
 
-  TEST_CASE("error types are properly set for just", "[factories][just]") {
+  TEST_CASE("error types are properly set for just", "[factories][just]")
+  {
     check_err_types<ex::__mset<>>(ex::just(1));
   }
 
-  TEST_CASE("just cannot call set_stopped", "[factories][just]") {
+  TEST_CASE("just cannot call set_stopped", "[factories][just]")
+  {
     check_sends_stopped<false>(ex::just(1));
   }
 
-  TEST_CASE("just works with value type", "[factories][just]") {
+  TEST_CASE("just works with value type", "[factories][just]")
+  {
     auto snd = ex::just(std::string{"hello"});
 
     // Check reported type
@@ -102,59 +114,67 @@ namespace {
 
     // Check received value
     std::string res;
-    typecat cat{typecat::undefined};
-    auto op =
-      ex::connect(std::move(snd), typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
+    typecat     cat{typecat::undefined};
+    auto        op = ex::connect(std::move(snd),
+                          typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
     ex::start(op);
     CHECK(res == "hello");
     CHECK(cat == typecat::rvalref);
   }
 
-  TEST_CASE("just works with ref type", "[factories][just]") {
+  TEST_CASE("just works with ref type", "[factories][just]")
+  {
     std::string original{"hello"};
-    auto snd = ex::just(original);
+    auto        snd = ex::just(original);
 
     // Check reported type
     check_val_types<ex::__mset<pack<std::string>>>(snd);
 
     // Check received value
     std::string res;
-    typecat cat{typecat::undefined};
-    auto op =
-      ex::connect(std::move(snd), typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
+    typecat     cat{typecat::undefined};
+    auto        op = ex::connect(std::move(snd),
+                          typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
     ex::start(op);
     CHECK(res == original);
     CHECK(cat == typecat::rvalref);
   }
 
-  TEST_CASE("just works with const-ref type", "[factories][just]") {
-    const std::string original{"hello"};
-    auto snd = ex::just(original);
+  TEST_CASE("just works with const-ref type", "[factories][just]")
+  {
+    std::string const original{"hello"};
+    auto              snd = ex::just(original);
 
     // Check reported type
     check_val_types<ex::__mset<pack<std::string>>>(snd);
 
     // Check received value
     std::string res;
-    typecat cat{typecat::undefined};
-    auto op =
-      ex::connect(std::move(snd), typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
+    typecat     cat{typecat::undefined};
+    auto        op = ex::connect(std::move(snd),
+                          typecat_receiver<std::string>{.value_ = &res, .cat_ = &cat});
     ex::start(op);
     CHECK(res == original);
     CHECK(cat == typecat::rvalref);
   }
 
-  TEST_CASE("just works with types with throwing move", "[factories][just]") {
-    struct throwing_move {
+  TEST_CASE("just works with types with throwing move", "[factories][just]")
+  {
+    struct throwing_move
+    {
       explicit throwing_move(std::size_t& throws_after) noexcept
-        : throws_after_(throws_after) {
-      }
-
-      throwing_move(throwing_move&& other) // NOLINT(bugprone-exception-escape)
-        : throws_after_(other.throws_after_) {
-        if (throws_after_) {
+        : throws_after_(throws_after)
+      {}
+
+      throwing_move(throwing_move&& other)  // NOLINT(bugprone-exception-escape)
+        : throws_after_(other.throws_after_)
+      {
+        if (throws_after_)
+        {
           --throws_after_;
-        } else {
+        }
+        else
+        {
           throw std::runtime_error("Throwing as requested");
         }
       }
@@ -162,38 +182,46 @@ namespace {
       std::size_t& throws_after_;
     };
 
-    std::size_t throws_after = 0;
-    const auto repeat_until_succeeds = [&](auto f) noexcept -> decltype(auto) {
-      struct guard {
-        ~guard() noexcept {
+    std::size_t throws_after          = 0;
+    auto const  repeat_until_succeeds = [&](auto f) noexcept -> decltype(auto)
+    {
+      struct guard
+      {
+        ~guard() noexcept
+        {
           CHECK(threw);
         }
         bool threw{false};
       };
       guard g;
-      for (;;) {
+      for (;;)
+      {
         auto orig = throws_after;
-        try {
+        try
+        {
           return f();
-        } catch (...) {
+        }
+        catch (...)
+        {
           g.threw = true;
           ++orig;
           throws_after = orig;
         }
       }
     };
-    auto sender = repeat_until_succeeds(
-      [&]() { return ::STDEXEC::just(throwing_move(throws_after)); });
+    auto sender = repeat_until_succeeds([&]()
+                                        { return ::STDEXEC::just(throwing_move(throws_after)); });
     CHECK(throws_after == 0);
     std::size_t invoked = 0;
-    auto op = repeat_until_succeeds([&]() {
-      return ::STDEXEC::connect(std::move(sender), make_fun_receiver([&](throwing_move&&) noexcept {
-                                  ++invoked;
-                                }));
-    });
+    auto        op      = repeat_until_succeeds(
+      [&]()
+      {
+        return ::STDEXEC::connect(std::move(sender),
+                                  make_fun_receiver([&](throwing_move&&) noexcept { ++invoked; }));
+      });
     CHECK(throws_after == 0);
     CHECK(invoked == 0);
     ::STDEXEC::start(op);
     CHECK(invoked == 1);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_just_error.cpp b/test/stdexec/algos/factories/test_just_error.cpp
index 7638c06a4..c969edf51 100644
--- a/test/stdexec/algos/factories/test_just_error.cpp
+++ b/test/stdexec/algos/factories/test_just_error.cpp
@@ -21,63 +21,73 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  constexpr int test_constexpr() noexcept {
-    struct receiver {
+  constexpr int test_constexpr() noexcept
+  {
+    struct receiver
+    {
       using receiver_concept = ex::receiver_t;
-      constexpr void set_error(const int j) && noexcept {
+      constexpr void set_error(int const j) && noexcept
+      {
         i = j;
       }
       int& i;
     };
-    int i = 0;
+    int  i  = 0;
     auto op = ex::connect(ex::just_error(5), receiver{i});
     ex::start(op);
     return i;
   }
   static_assert(test_constexpr() == 5);
 
-  TEST_CASE("Simple test for just_error", "[factories][just_error]") {
+  TEST_CASE("Simple test for just_error", "[factories][just_error]")
+  {
     auto op = ex::connect(ex::just_error(std::exception_ptr{}), expect_error_receiver{});
     ex::start(op);
     // receiver ensures that set_error() is called
   }
 
-  TEST_CASE("just_error returns a sender", "[factories][just_error]") {
+  TEST_CASE("just_error returns a sender", "[factories][just_error]")
+  {
     using t = decltype(ex::just_error(std::exception_ptr{}));
     static_assert(ex::sender<t>, "ex::just_error must return a sender");
   }
 
-  TEST_CASE("just_error returns a typed sender", "[factories][just_error]") {
+  TEST_CASE("just_error returns a typed sender", "[factories][just_error]")
+  {
     using t = decltype(ex::just_error(std::exception_ptr{}));
     static_assert(ex::sender_in<t, ex::env<>>, "ex::just_error must return a sender");
   }
 
-  TEST_CASE("error types are properly set for just_error<int>", "[factories][just_error]") {
+  TEST_CASE("error types are properly set for just_error<int>", "[factories][just_error]")
+  {
     check_err_types<ex::__mset<int>>(ex::just_error(1));
   }
 
-  TEST_CASE(
-    "error types are properly set for just_error<exception_ptr>",
-    "[factories][just_error]") {
+  TEST_CASE("error types are properly set for just_error<exception_ptr>", "[factories][just_error]")
+  {
     // we should not get std::exception_ptr twice
     check_err_types<ex::__mset<std::exception_ptr>>(ex::just_error(std::exception_ptr()));
   }
 
-  TEST_CASE("value types are properly set for just_error", "[factories][just_error]") {
+  TEST_CASE("value types are properly set for just_error", "[factories][just_error]")
+  {
     // there is no variant of calling `set_value(recv)`
     check_val_types<ex::__mset<>>(ex::just_error(1));
   }
 
-  TEST_CASE("just_error cannot call set_stopped", "[factories][just_error]") {
+  TEST_CASE("just_error cannot call set_stopped", "[factories][just_error]")
+  {
     check_sends_stopped<false>(ex::just_error(1));
   }
 
-  TEST_CASE("just_error removes cv qualifier for the given type", "[factories][just_error]") {
-    std::string str{"hello"};
-    const std::string& crefstr = str;
-    auto snd = ex::just_error(crefstr);
+  TEST_CASE("just_error removes cv qualifier for the given type", "[factories][just_error]")
+  {
+    std::string         str{"hello"};
+    std::string const & crefstr = str;
+    auto                snd     = ex::just_error(crefstr);
     check_err_types<ex::__mset<std::string>>(snd);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_just_stopped.cpp b/test/stdexec/algos/factories/test_just_stopped.cpp
index 7593798a7..0ca49be99 100644
--- a/test/stdexec/algos/factories/test_just_stopped.cpp
+++ b/test/stdexec/algos/factories/test_just_stopped.cpp
@@ -19,52 +19,62 @@
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
-namespace {
+namespace
+{
 
 #if !STDEXEC_GCC() || STDEXEC_GCC_VERSION >= 12'00
-  constexpr int test_constexpr() noexcept {
-    struct receiver {
+  constexpr int test_constexpr() noexcept
+  {
+    struct receiver
+    {
       using receiver_concept = ex::receiver_t;
-      constexpr void set_stopped() && noexcept {
+      constexpr void set_stopped() && noexcept
+      {
         invoked = true;
       }
       bool& invoked;
     };
     bool invoked = false;
-    auto op = ex::connect(ex::just_stopped(), receiver{invoked});
+    auto op      = ex::connect(ex::just_stopped(), receiver{invoked});
     ex::start(op);
     return invoked;
   }
   static_assert(test_constexpr());
 #endif
 
-  TEST_CASE("Simple test for just_stopped", "[factories][just_stopped]") {
+  TEST_CASE("Simple test for just_stopped", "[factories][just_stopped]")
+  {
     auto op = ex::connect(ex::just_stopped(), expect_stopped_receiver{});
     ex::start(op);
     // receiver ensures that set_stopped() is called
   }
 
-  TEST_CASE("just_stopped returns a sender", "[factories][just_stopped]") {
+  TEST_CASE("just_stopped returns a sender", "[factories][just_stopped]")
+  {
     using t = decltype(ex::just_stopped());
     static_assert(ex::sender<t>, "ex::just_stopped must return a sender");
     REQUIRE(ex::sender<t>);
   }
 
-  TEST_CASE("just_stopped returns a typed sender", "[factories][just_stopped]") {
+  TEST_CASE("just_stopped returns a typed sender", "[factories][just_stopped]")
+  {
     using t = decltype(ex::just_stopped());
     static_assert(ex::sender_in<t, ex::env<>>, "ex::just_stopped must return a sender");
   }
 
-  TEST_CASE("value types are properly set for just_stopped", "[factories][just_stopped]") {
+  TEST_CASE("value types are properly set for just_stopped", "[factories][just_stopped]")
+  {
     check_val_types<ex::__mset<>>(ex::just_stopped());
   }
 
-  TEST_CASE("error types are properly set for just_stopped", "[factories][just_stopped]") {
+  TEST_CASE("error types are properly set for just_stopped", "[factories][just_stopped]")
+  {
     // no errors sent by just_stopped
     check_err_types<ex::__mset<>>(ex::just_stopped());
   }
 
-  TEST_CASE("just_stopped advertises that it can call set_stopped", "[factories][just_stopped]") {
+  TEST_CASE("just_stopped advertises that it can call set_stopped", "[factories][just_stopped]")
+  {
     check_sends_stopped<true>(ex::just_stopped());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_read.cpp b/test/stdexec/algos/factories/test_read.cpp
index 700fb16f0..b8d43f40d 100644
--- a/test/stdexec/algos/factories/test_read.cpp
+++ b/test/stdexec/algos/factories/test_read.cpp
@@ -20,15 +20,17 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("read returns empty env", "[factories][read]") {
-    auto sndr = ex::read_env(ex::get_allocator);
+  TEST_CASE("read returns empty env", "[factories][read]")
+  {
+    auto sndr  = ex::read_env(ex::get_allocator);
     using Sndr = decltype(sndr);
-    using Env = ex::prop<ex::get_allocator_t, std::allocator<int>>;
+    using Env  = ex::prop<ex::get_allocator_t, std::allocator<int>>;
     static_assert(ex::sender<Sndr>);
     static_assert(!ex::sender_in<Sndr>);
     static_assert(ex::sender_in<Sndr, Env>);
     static_assert(ex::__is_scheduler_affine<Sndr, Env>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_schedule.cpp b/test/stdexec/algos/factories/test_schedule.cpp
index 1aab6e7fc..cef18932c 100644
--- a/test/stdexec/algos/factories/test_schedule.cpp
+++ b/test/stdexec/algos/factories/test_schedule.cpp
@@ -23,18 +23,22 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
   template <ex::scheduler Sched = inline_scheduler>
-  inline auto _with_scheduler(Sched sched = {}) {
+  inline auto _with_scheduler(Sched sched = {})
+  {
     return ex::write_env(ex::prop{ex::get_scheduler, std::move(sched)});
   }
 
-  TEST_CASE("schedule returns a sender", "[factories][schedule]") {
+  TEST_CASE("schedule returns a sender", "[factories][schedule]")
+  {
     using sndr = ex::schedule_result_t<inline_scheduler>;
     static_assert(ex::sender<sndr>);
   }
 
-  TEST_CASE("schedule advertices scheduler and domain", "[factories][schedule]") {
+  TEST_CASE("schedule advertices scheduler and domain", "[factories][schedule]")
+  {
     using target_sched = exec::static_thread_pool::scheduler;
     using target_domain =
       ex::__call_result_t<ex::get_completion_domain_t<ex::set_value_t>, target_sched, ex::env<>>;
@@ -73,4 +77,4 @@ namespace {
     STATIC_REQUIRE(std::is_same_v<scheduler_with_inline_sender, target_sched>);
     STATIC_REQUIRE(std::is_same_v<domain_with_inline_sender, target_domain>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/algos/factories/test_transfer_just.cpp b/test/stdexec/algos/factories/test_transfer_just.cpp
index 224fe7db1..eea278bf0 100644
--- a/test/stdexec/algos/factories/test_transfer_just.cpp
+++ b/test/stdexec/algos/factories/test_transfer_just.cpp
@@ -22,39 +22,43 @@
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("transfer_just returns a sender", "[factories][transfer_just]") {
+namespace
+{
+  TEST_CASE("transfer_just returns a sender", "[factories][transfer_just]")
+  {
     auto snd = ex::transfer_just(inline_scheduler{}, 13);
     static_assert(ex::sender<decltype(snd)>);
     (void) snd;
   }
 
-  TEST_CASE("transfer_just with environment returns a sender", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just with environment returns a sender", "[factories][transfer_just]")
+  {
     auto snd = ex::transfer_just(inline_scheduler{}, 13);
     static_assert(ex::sender_in<decltype(snd), ex::env<>>);
     (void) snd;
   }
 
-  TEST_CASE("transfer_just simple example", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just simple example", "[factories][transfer_just]")
+  {
     inline_scheduler sched;
-    auto snd = ex::transfer_just(sched, 13);
+    auto             snd = ex::transfer_just(sched, 13);
     //auto op = std::move(snd).connect(expect_value_receiver{13});
     auto op = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE(
-    "transfer_just calls the receiver when the scheduler dictates",
-    "[factories][transfer_just]") {
-    int recv_value{0};
+  TEST_CASE("transfer_just calls the receiver when the scheduler dictates",
+            "[factories][transfer_just]")
+  {
+    int               recv_value{0};
     impulse_scheduler sched;
-    auto snd = ex::transfer_just(sched, 13);
-    auto op = ex::connect(snd, expect_value_receiver_ex{recv_value});
+    auto              snd = ex::transfer_just(sched, 13);
+    auto              op  = ex::connect(snd, expect_value_receiver_ex{recv_value});
     ex::start(op);
     // Up until this point, the scheduler didn't start any task; no effect expected
     CHECK(recv_value == 0);
@@ -64,63 +68,70 @@ namespace {
     CHECK(recv_value == 13);
   }
 
-  TEST_CASE("transfer_just can be called with value type scheduler", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just can be called with value type scheduler", "[factories][transfer_just]")
+  {
     auto snd = ex::transfer_just(inline_scheduler{}, 13);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("transfer_just can be called with rvalue ref scheduler", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just can be called with rvalue ref scheduler", "[factories][transfer_just]")
+  {
     auto snd = ex::transfer_just(inline_scheduler{}, 13);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("transfer_just can be called with const ref scheduler", "[factories][transfer_just]") {
-    const inline_scheduler sched;
-    auto snd = ex::transfer_just(sched, 13);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+  TEST_CASE("transfer_just can be called with const ref scheduler", "[factories][transfer_just]")
+  {
+    inline_scheduler const sched;
+    auto                   snd = ex::transfer_just(sched, 13);
+    auto                   op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("transfer_just can be called with ref scheduler", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just can be called with ref scheduler", "[factories][transfer_just]")
+  {
     inline_scheduler sched;
-    auto snd = ex::transfer_just(sched, 13);
-    auto op = ex::connect(std::move(snd), expect_value_receiver{13});
+    auto             snd = ex::transfer_just(sched, 13);
+    auto             op  = ex::connect(std::move(snd), expect_value_receiver{13});
     ex::start(op);
     // The receiver checks if we receive the right value
   }
 
-  TEST_CASE("transfer_just forwards set_error calls", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just forwards set_error calls", "[factories][transfer_just]")
+  {
     error_scheduler<std::exception_ptr> sched{std::exception_ptr{}};
-    auto snd = ex::transfer_just(sched, 13);
-    auto op = ex::connect(std::move(snd), expect_error_receiver{});
+    auto                                snd = ex::transfer_just(sched, 13);
+    auto                                op  = ex::connect(std::move(snd), expect_error_receiver{});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("transfer_just forwards set_error calls of other types", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just forwards set_error calls of other types", "[factories][transfer_just]")
+  {
     error_scheduler<std::string> sched{std::string{"error"}};
-    auto snd = ex::transfer_just(sched, 13);
+    auto                         snd = ex::transfer_just(sched, 13);
     auto op = ex::connect(std::move(snd), expect_error_receiver{std::string{"error"}});
     ex::start(op);
     // The receiver checks if we receive an error
   }
 
-  TEST_CASE("transfer_just forwards set_stopped calls", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just forwards set_stopped calls", "[factories][transfer_just]")
+  {
     stopped_scheduler sched{};
-    auto snd = ex::transfer_just(sched, 13);
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto              snd = ex::transfer_just(sched, 13);
+    auto              op  = ex::connect(std::move(snd), expect_stopped_receiver{});
     ex::start(op);
     // The receiver checks if we receive the stopped signal
   }
 
-  TEST_CASE(
-    "transfer_just has the values_type corresponding to the given values",
-    "[factories][transfer_just]") {
+  TEST_CASE("transfer_just has the values_type corresponding to the given values",
+            "[factories][transfer_just]")
+  {
     inline_scheduler sched{};
 
     check_val_types<ex::__mset<pack<int>>>(ex::transfer_just(sched, 1));
@@ -129,11 +140,10 @@ namespace {
       ex::transfer_just(sched, 3, 0.14, std::string{"pi"}));
   }
 
-  TEST_CASE(
-    "transfer_just keeps error_types from scheduler's sender",
-    "[factories][transfer_just]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("transfer_just keeps error_types from scheduler's sender", "[factories][transfer_just]")
+  {
+    inline_scheduler     sched1{};
+    error_scheduler      sched2{};
     error_scheduler<int> sched3{43};
 
     check_err_types<ex::__mset<>>(ex::transfer_just(sched1, 1));
@@ -141,20 +151,21 @@ namespace {
     check_err_types<ex::__mset<int>>(ex::transfer_just(sched3, 3));
   }
 
-  TEST_CASE(
-    "transfer_just sends an exception_ptr if value types are potentially throwing when copied",
-    "[factories][transfer_just]") {
+  TEST_CASE("transfer_just sends an exception_ptr if value types are potentially throwing when "
+            "copied",
+            "[factories][transfer_just]")
+  {
     inline_scheduler sched{};
 
     check_err_types<ex::__mset<std::exception_ptr>>(
       ex::transfer_just(sched, potentially_throwing{}));
   }
 
-  TEST_CASE(
-    "transfer_just keeps sends_stopped from scheduler's sender",
-    "[factories][transfer_just]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("transfer_just keeps sends_stopped from scheduler's sender",
+            "[factories][transfer_just]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
     check_sends_stopped<false>(ex::transfer_just(sched1, 1));
@@ -162,44 +173,45 @@ namespace {
     check_sends_stopped<true>(ex::transfer_just(sched3, 3));
   }
 
-  TEST_CASE("transfer_just advertises its completion scheduler", "[factories][transfer_just]") {
-    inline_scheduler sched1{};
-    error_scheduler sched2{};
+  TEST_CASE("transfer_just advertises its completion scheduler", "[factories][transfer_just]")
+  {
+    inline_scheduler  sched1{};
+    error_scheduler   sched2{};
     stopped_scheduler sched3{};
 
-    REQUIRE(
-      ex::get_completion_scheduler<ex::set_value_t>(
-        ex::get_env(ex::transfer_just(sched1, 1)), ex::env<>{})
-      == sched1);
+    REQUIRE(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(ex::transfer_just(sched1, 1)),
+                                                          ex::env<>{})
+            == sched1);
 
-    REQUIRE(
-      ex::get_completion_scheduler<ex::set_value_t>(
-        ex::get_env(ex::transfer_just(sched2, 2)), ex::env<>{})
-      == sched2);
+    REQUIRE(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(ex::transfer_just(sched2, 2)),
+                                                          ex::env<>{})
+            == sched2);
 
-    REQUIRE(
-      ex::get_completion_scheduler<ex::set_value_t>(
-        ex::get_env(ex::transfer_just(sched3, 3)), ex::env<>{})
-      == sched3);
+    REQUIRE(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(ex::transfer_just(sched3, 3)),
+                                                          ex::env<>{})
+            == sched3);
   }
 
   // Modify the value when we invoke this custom defined transfer_just implementation
-  struct transfer_just_test_domain {
+  struct transfer_just_test_domain
+  {
     template <ex::sender_expr_for<ex::__transfer_just_t> Sender>
-    static auto transform_sender(STDEXEC::set_value_t, Sender&& sndr, auto&&...) {
-      auto&& [tag, data] = sndr;
+    static auto transform_sender(STDEXEC::set_value_t, Sender&& sndr, auto&&...)
+    {
+      auto&& [tag, data]  = sndr;
       auto [sched, value] = data;
       return ex::continues_on(ex::just("Hello, " + value), sched);
     }
   };
 
-  TEST_CASE("transfer_just can be customized", "[factories][transfer_just]") {
+  TEST_CASE("transfer_just can be customized", "[factories][transfer_just]")
+  {
     // The customization will alter the value passed in
     basic_inline_scheduler<transfer_just_test_domain> sched;
-    auto snd = ex::transfer_just(sched, std::string{"world"});
+    auto        snd = ex::transfer_just(sched, std::string{"world"});
     std::string res;
-    auto op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
+    auto        op = ex::connect(std::move(snd), expect_value_receiver_ex{res});
     ex::start(op);
     REQUIRE(res == "Hello, world");
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/concepts/test_awaitables.cpp b/test/stdexec/concepts/test_awaitables.cpp
index 714632aae..c9877d459 100644
--- a/test/stdexec/concepts/test_awaitables.cpp
+++ b/test/stdexec/concepts/test_awaitables.cpp
@@ -26,100 +26,120 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   template <class Sender>
-  concept sender_with_env = ex::sender<Sender> && requires(const Sender& s) { ex::get_env(s); };
+  concept sender_with_env = ex::sender<Sender> && requires(Sender const & s) { ex::get_env(s); };
 
   template <typename Awaiter>
-  struct promise {
-    auto get_return_object() -> ex::__std::coroutine_handle<promise> {
+  struct promise
+  {
+    auto get_return_object() -> ex::__std::coroutine_handle<promise>
+    {
       return {ex::__std::coroutine_handle<promise>::from_promise(*this)};
     }
 
-    auto initial_suspend() noexcept -> ex::__std::suspend_always {
+    auto initial_suspend() noexcept -> ex::__std::suspend_always
+    {
       return {};
     }
 
-    auto final_suspend() noexcept -> ex::__std::suspend_always {
+    auto final_suspend() noexcept -> ex::__std::suspend_always
+    {
       return {};
     }
 
-    void return_void() {
-    }
+    void return_void() {}
 
-    void unhandled_exception() {
-    }
+    void unhandled_exception() {}
 
     template <typename... T>
-    auto await_transform(T&&...) noexcept {
+    auto await_transform(T&&...) noexcept
+    {
       return Awaiter{};
     }
   };
 
-  struct awaiter {
-    auto await_ready() -> bool {
+  struct awaiter
+  {
+    auto await_ready() -> bool
+    {
       return true;
     }
 
-    auto await_suspend(ex::__std::coroutine_handle<>) -> bool {
+    auto await_suspend(ex::__std::coroutine_handle<>) -> bool
+    {
       return false;
     }
 
-    auto await_resume() -> bool {
+    auto await_resume() -> bool
+    {
       return false;
     }
   };
 
-  struct invalid_awaiter {
+  struct invalid_awaiter
+  {
     auto await_ready() -> bool;
     auto await_suspend(ex::__std::coroutine_handle<>) -> bool;
     //void await_resume();
   };
 
   template <typename Awaiter>
-  struct awaitable_sender_1 {
-    auto operator co_await() -> Awaiter {
+  struct awaitable_sender_1
+  {
+    auto operator co_await() -> Awaiter
+    {
       return {};
     }
   };
 
-  struct awaitable_sender_2 {
+  struct awaitable_sender_2
+  {
     using promise_type = promise<ex::__std::suspend_always>;
 
    private:
-    friend auto operator co_await(awaitable_sender_2) -> invalid_awaiter {
+    friend auto operator co_await(awaitable_sender_2) -> invalid_awaiter
+    {
       return {};
     }
   };
 
-  struct awaitable_sender_3 {
+  struct awaitable_sender_3
+  {
     using promise_type = promise<awaiter>;
 
    private:
-    friend auto operator co_await(awaitable_sender_3) -> invalid_awaiter {
+    friend auto operator co_await(awaitable_sender_3) -> invalid_awaiter
+    {
       return {};
     }
   };
 
-  struct awaitable_sender_4 {
+  struct awaitable_sender_4
+  {
     using promise_type = promise<ex::__std::suspend_always>;
 
     template <class Promise>
-    auto as_awaitable(Promise&) const -> awaiter {
+    auto as_awaitable(Promise&) const -> awaiter
+    {
       return {};
     }
   };
 
-  struct awaitable_sender_5 {
+  struct awaitable_sender_5
+  {
     template <class Promise>
-    auto as_awaitable(Promise&) const -> awaiter {
+    auto as_awaitable(Promise&) const -> awaiter
+    {
       return {};
     }
   };
 
   template <typename Signatures, typename Awaiter>
-  void test_awaitable_sender1(Signatures*, Awaiter&&) {
+  void test_awaitable_sender1(Signatures*, Awaiter&&)
+  {
     static_assert(ex::sender<awaitable_sender_1<Awaiter>>);
     static_assert(sender_with_env<awaitable_sender_1<Awaiter>>);
     static_assert(ex::__awaitable<awaitable_sender_1<Awaiter>>);
@@ -129,7 +149,8 @@ namespace {
       std::is_same_v<ex::completion_signatures_of_t<awaitable_sender_1<Awaiter>>, Signatures>);
   }
 
-  void test_awaitable_sender2() {
+  void test_awaitable_sender2()
+  {
     static_assert(!ex::sender<awaitable_sender_2>);
     static_assert(!sender_with_env<awaitable_sender_2>);
     static_assert(!ex::sender_in<awaitable_sender_2, ex::env<>>);
@@ -140,7 +161,8 @@ namespace {
     static_assert(!ex::__cmplsigs::__with_legacy_member_alias<awaitable_sender_2>);
   }
 
-  void test_awaitable_sender3() {
+  void test_awaitable_sender3()
+  {
     static_assert(!ex::sender<awaitable_sender_3>);
     static_assert(!sender_with_env<awaitable_sender_3>);
     static_assert(!ex::sender_in<awaitable_sender_3, ex::env<>>);
@@ -153,7 +175,8 @@ namespace {
   }
 
   template <class Signatures>
-  void test_awaitable_sender4(Signatures*) {
+  void test_awaitable_sender4(Signatures*)
+  {
     static_assert(ex::sender<awaitable_sender_4>);
     static_assert(sender_with_env<awaitable_sender_4>);
     static_assert(ex::sender_in<awaitable_sender_4, ex::env<>>);
@@ -171,10 +194,12 @@ namespace {
       std::is_same_v<ex::completion_signatures_of_t<awaitable_sender_4, ex::env<>>, Signatures>);
   }
 
-  struct connect_awaitable_promise : ex::with_awaitable_senders<connect_awaitable_promise> { };
+  struct connect_awaitable_promise : ex::with_awaitable_senders<connect_awaitable_promise>
+  {};
 
   template <class Signatures>
-  void test_awaitable_sender5(Signatures*) {
+  void test_awaitable_sender5(Signatures*)
+  {
     static_assert(ex::sender<awaitable_sender_5>);
     static_assert(sender_with_env<awaitable_sender_5>);
     static_assert(!ex::sender_in<awaitable_sender_5>);
@@ -192,61 +217,69 @@ namespace {
   }
 
   template <typename Error, typename... Values>
-  auto signature_error_values(Error, Values...) -> ex::completion_signatures<
-    ex::set_value_t(Values...),
-    ex::set_error_t(Error),
-    ex::set_stopped_t()
-  >* {
+  auto
+  signature_error_values(Error, Values...) -> ex::completion_signatures<ex::set_value_t(Values...),
+                                                                        ex::set_error_t(Error),
+                                                                        ex::set_stopped_t()>*
+  {
     return {};
   }
 
-  TEST_CASE("get completion_signatures for awaitables", "[sndtraits][awaitables]") {
-    ::test_awaitable_sender1(
-      signature_error_values(std::exception_ptr()), ex::__std::suspend_always{});
+  TEST_CASE("get completion_signatures for awaitables", "[sndtraits][awaitables]")
+  {
+    ::test_awaitable_sender1(signature_error_values(std::exception_ptr()),
+                             ex::__std::suspend_always{});
     ::test_awaitable_sender1(
-      signature_error_values(
-        std::exception_ptr(), ex::__await_result_t<awaitable_sender_1<awaiter>>()),
+      signature_error_values(std::exception_ptr(),
+                             ex::__await_result_t<awaitable_sender_1<awaiter>>()),
       awaiter{});
 
     ::test_awaitable_sender2();
 
     ::test_awaitable_sender3();
 
-    ::test_awaitable_sender4(signature_error_values(
-      std::exception_ptr(), ex::__await_result_t<awaitable_sender_4, promise<awaiter>>()));
+    ::test_awaitable_sender4(
+      signature_error_values(std::exception_ptr(),
+                             ex::__await_result_t<awaitable_sender_4, promise<awaiter>>()));
 
     ::test_awaitable_sender5(signature_error_values(
-      std::exception_ptr(), ex::__await_result_t<awaitable_sender_5, connect_awaitable_promise>()));
+      std::exception_ptr(),
+      ex::__await_result_t<awaitable_sender_5, connect_awaitable_promise>()));
   }
 
-  struct awaitable_env { };
+  struct awaitable_env
+  {};
 
   template <typename Awaiter>
-  struct awaitable_with_get_env {
+  struct awaitable_with_get_env
+  {
     auto operator co_await() -> Awaiter;
 
     [[nodiscard]]
-    auto get_env() const noexcept -> awaitable_env {
+    auto get_env() const noexcept -> awaitable_env
+    {
       return {};
     }
   };
 
-  TEST_CASE("get_env for awaitables", "[sndtraits][awaitables]") {
+  TEST_CASE("get_env for awaitables", "[sndtraits][awaitables]")
+  {
     check_env_type<ex::env<>>(awaitable_sender_1<awaiter>{});
     check_env_type<ex::env<>>(awaitable_sender_2{});
     check_env_type<ex::env<>>(awaitable_sender_3{});
     check_env_type<awaitable_env>(awaitable_with_get_env<awaiter>{});
   }
 
-  TEST_CASE("env_promise bug when CWG 2369 is fixed", "[sndtraits][awaitables]") {
+  TEST_CASE("env_promise bug when CWG 2369 is fixed", "[sndtraits][awaitables]")
+  {
     exec::static_thread_pool ctx{1};
-    ex::scheduler auto sch = ctx.get_scheduler();
-    ex::sender auto snd = ex::when_all(ex::then(ex::schedule(sch), []() { }));
+    ex::scheduler auto       sch = ctx.get_scheduler();
+    ex::sender auto          snd = ex::when_all(ex::then(ex::schedule(sch), []() {}));
 
     using _Awaitable = decltype(snd);
-    using _Promise = ex::__detail::__promise<ex::env<>>;
+    using _Promise   = ex::__detail::__promise<ex::env<>>;
     static_assert(!ex::__awaitable<_Awaitable, _Promise>);
   }
-} // namespace
+}  // namespace
 
-#endif // STDEXEC_NO_STD_COROUTINES()
+#endif  // STDEXEC_NO_STD_COROUTINES()
diff --git a/test/stdexec/concepts/test_concept_operation_state.cpp b/test/stdexec/concepts/test_concept_operation_state.cpp
index a36c15740..033f8bac1 100644
--- a/test/stdexec/concepts/test_concept_operation_state.cpp
+++ b/test/stdexec/concepts/test_concept_operation_state.cpp
@@ -19,26 +19,27 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   STDEXEC_PRAGMA_PUSH()
   STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
   STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-  struct op_except {
-    op_except() = default;
+  struct op_except
+  {
+    op_except()            = default;
     op_except(op_except&&) = delete;
 
-    void start() & {
-    }
+    void start() & {}
   };
 
-  struct op_noexcept {
-    op_noexcept() = default;
+  struct op_noexcept
+  {
+    op_noexcept()              = default;
     op_noexcept(op_noexcept&&) = delete;
 
-    void start() & noexcept {
-    }
+    void start() & noexcept {}
   };
 
   STDEXEC_PRAGMA_POP()
@@ -49,15 +50,18 @@ namespace {
   //   REQUIRE(!ex::operation_state<op_except>);
   // }
 
-  TEST_CASE("type with start CPO noexcept is an operation_state", "[concepts][operation_state]") {
+  TEST_CASE("type with start CPO noexcept is an operation_state", "[concepts][operation_state]")
+  {
     REQUIRE(ex::operation_state<op_noexcept>);
   }
 
-  TEST_CASE("reference type is not an operation_state", "[concepts][operation_state]") {
+  TEST_CASE("reference type is not an operation_state", "[concepts][operation_state]")
+  {
     REQUIRE(!ex::operation_state<op_noexcept&>);
   }
 
-  TEST_CASE("pointer type is not an operation_state", "[concepts][operation_state]") {
+  TEST_CASE("pointer type is not an operation_state", "[concepts][operation_state]")
+  {
     REQUIRE(!ex::operation_state<op_noexcept*>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/concepts/test_concept_scheduler.cpp b/test/stdexec/concepts/test_concept_scheduler.cpp
index 57bf0d9c4..62ed1db24 100644
--- a/test/stdexec/concepts/test_concept_scheduler.cpp
+++ b/test/stdexec/concepts/test_concept_scheduler.cpp
@@ -23,28 +23,32 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-namespace {
+namespace
+{
 
   template <class Scheduler>
-  struct default_env {
+  struct default_env
+  {
     template <typename CPO>
     [[nodiscard]]
-    auto query(ex::get_completion_scheduler_t<CPO>, ex::__ignore = {}) const noexcept -> Scheduler {
+    auto query(ex::get_completion_scheduler_t<CPO>, ex::__ignore = {}) const noexcept -> Scheduler
+    {
       return {};
     }
   };
 
-  struct my_scheduler {
-    struct my_sender {
-      using sender_concept = STDEXEC::sender_t;
-      using completion_signatures = ex::completion_signatures<
-        ex::set_value_t(),
-        ex::set_error_t(std::exception_ptr),
-        ex::set_stopped_t()
-      >;
+  struct my_scheduler
+  {
+    struct my_sender
+    {
+      using sender_concept        = STDEXEC::sender_t;
+      using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                              ex::set_error_t(std::exception_ptr),
+                                                              ex::set_stopped_t()>;
 
       [[nodiscard]]
-      auto get_env() const noexcept -> default_env<my_scheduler> {
+      auto get_env() const noexcept -> default_env<my_scheduler>
+      {
         return {};
       }
     };
@@ -52,93 +56,108 @@ namespace {
     template <typename CPO>
     [[nodiscard]]
     auto
-      query(ex::get_completion_scheduler_t<CPO>, ex::__ignore = {}) const noexcept -> my_scheduler {
+    query(ex::get_completion_scheduler_t<CPO>, ex::__ignore = {}) const noexcept -> my_scheduler
+    {
       return {};
     }
 
     [[nodiscard]]
-    auto schedule() const -> my_sender {
+    auto schedule() const -> my_sender
+    {
       return {};
     }
 
-    friend auto operator==(my_scheduler, my_scheduler) noexcept -> bool {
+    friend auto operator==(my_scheduler, my_scheduler) noexcept -> bool
+    {
       return true;
     }
 
-    friend auto operator!=(my_scheduler, my_scheduler) noexcept -> bool {
+    friend auto operator!=(my_scheduler, my_scheduler) noexcept -> bool
+    {
       return false;
     }
   };
 
-  TEST_CASE("type with schedule CPO models scheduler", "[concepts][scheduler]") {
+  TEST_CASE("type with schedule CPO models scheduler", "[concepts][scheduler]")
+  {
     REQUIRE(ex::scheduler<my_scheduler>);
     REQUIRE(ex::sender<decltype(ex::schedule(my_scheduler{}))>);
   }
 
-  struct no_schedule_cpo { };
+  struct no_schedule_cpo
+  {};
 
-  TEST_CASE("type without schedule CPO doesn't model scheduler", "[concepts][scheduler]") {
+  TEST_CASE("type without schedule CPO doesn't model scheduler", "[concepts][scheduler]")
+  {
     REQUIRE(!ex::scheduler<no_schedule_cpo>);
   }
 
-  struct my_scheduler_except {
-    struct my_sender {
-      using sender_concept = STDEXEC::sender_t;
-      using completion_signatures = ex::completion_signatures<
-        ex::set_value_t(),
-        ex::set_error_t(std::exception_ptr),
-        ex::set_stopped_t()
-      >;
+  struct my_scheduler_except
+  {
+    struct my_sender
+    {
+      using sender_concept        = STDEXEC::sender_t;
+      using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                              ex::set_error_t(std::exception_ptr),
+                                                              ex::set_stopped_t()>;
 
       [[nodiscard]]
-      auto get_env() const noexcept -> default_env<my_scheduler_except> {
+      auto get_env() const noexcept -> default_env<my_scheduler_except>
+      {
         return {};
       }
     };
 
     [[nodiscard]]
-    auto schedule() const -> my_sender {
+    auto schedule() const -> my_sender
+    {
       STDEXEC_THROW(std::logic_error("err"));
       return {};
     }
 
-    friend auto operator==(my_scheduler_except, my_scheduler_except) noexcept -> bool {
+    friend auto operator==(my_scheduler_except, my_scheduler_except) noexcept -> bool
+    {
       return true;
     }
 
-    friend auto operator!=(my_scheduler_except, my_scheduler_except) noexcept -> bool {
+    friend auto operator!=(my_scheduler_except, my_scheduler_except) noexcept -> bool
+    {
       return false;
     }
   };
 
-  TEST_CASE("type with schedule that throws is a scheduler", "[concepts][scheduler]") {
+  TEST_CASE("type with schedule that throws is a scheduler", "[concepts][scheduler]")
+  {
     REQUIRE(ex::scheduler<my_scheduler_except>);
   }
 
-  struct noeq_sched {
-    struct my_sender {
-      using sender_concept = STDEXEC::sender_t;
-      using completion_signatures = ex::completion_signatures<
-        ex::set_value_t(),
-        ex::set_error_t(std::exception_ptr),
-        ex::set_stopped_t()
-      >;
+  struct noeq_sched
+  {
+    struct my_sender
+    {
+      using sender_concept        = STDEXEC::sender_t;
+      using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                              ex::set_error_t(std::exception_ptr),
+                                                              ex::set_stopped_t()>;
 
       [[nodiscard]]
-      auto get_env() const noexcept -> default_env<noeq_sched> {
+      auto get_env() const noexcept -> default_env<noeq_sched>
+      {
         return {};
       }
     };
 
     [[nodiscard]]
-    auto schedule() const -> my_sender {
+    auto schedule() const -> my_sender
+    {
       return {};
     }
   };
 
-  TEST_CASE("type w/o equality operations do not model scheduler", "[concepts][scheduler]") {
+  TEST_CASE("type w/o equality operations do not model scheduler", "[concepts][scheduler]")
+  {
     REQUIRE(!ex::scheduler<noeq_sched>);
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
\ No newline at end of file
diff --git a/test/stdexec/concepts/test_concepts_receiver.cpp b/test/stdexec/concepts/test_concepts_receiver.cpp
index 32ad255ec..bca95dd32 100644
--- a/test/stdexec/concepts/test_concepts_receiver.cpp
+++ b/test/stdexec/concepts/test_concepts_receiver.cpp
@@ -20,109 +20,109 @@
 
 namespace ex = STDEXEC;
 
-struct recv_no_set_value {
+struct recv_no_set_value
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  void set_stopped() noexcept {
-  }
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_stopped() noexcept {}
+  void set_error(std::exception_ptr) noexcept {}
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
 
-struct recv_set_value_except {
+struct recv_set_value_except
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  void set_value() {
-  }
-  void set_stopped() noexcept {
-  }
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_value() {}
+  void set_stopped() noexcept {}
+  void set_error(std::exception_ptr) noexcept {}
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
 
-struct recv_set_value_noexcept {
+struct recv_set_value_noexcept
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  void set_value() noexcept {
-  }
-  void set_stopped() noexcept {
-  }
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_value() noexcept {}
+  void set_stopped() noexcept {}
+  void set_error(std::exception_ptr) noexcept {}
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
 
-struct recv_set_error_except {
+struct recv_set_error_except
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  void set_value() noexcept {
-  }
-  void set_stopped() noexcept {
-  }
-  void set_error(std::exception_ptr) {
+  void set_value() noexcept {}
+  void set_stopped() noexcept {}
+  void set_error(std::exception_ptr)
+  {
     throw std::logic_error{"err"};
   }
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
-struct recv_set_stopped_except {
+struct recv_set_stopped_except
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  void set_value() noexcept {
-  }
-  void set_stopped() {
+  void set_value() noexcept {}
+  void set_stopped()
+  {
     throw std::logic_error{"err"};
   }
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_error(std::exception_ptr) noexcept {}
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
 
-struct recv_non_movable {
+struct recv_non_movable
+{
   using receiver_concept = STDEXEC::receiver_t;
 
-  recv_non_movable() = default;
-  ~recv_non_movable() = default;
-  recv_non_movable(recv_non_movable&&) = delete;
-  recv_non_movable& operator=(recv_non_movable&&) = delete;
-  recv_non_movable(const recv_non_movable&) = default;
-  recv_non_movable& operator=(const recv_non_movable&) = default;
+  recv_non_movable()                                    = default;
+  ~recv_non_movable()                                   = default;
+  recv_non_movable(recv_non_movable&&)                  = delete;
+  recv_non_movable& operator=(recv_non_movable&&)       = delete;
+  recv_non_movable(recv_non_movable const &)            = default;
+  recv_non_movable& operator=(recv_non_movable const &) = default;
 
-  void set_value() noexcept {
-  }
-  void set_stopped() noexcept {
-  }
-  void set_error(std::exception_ptr) noexcept {
-  }
+  void set_value() noexcept {}
+  void set_stopped() noexcept {}
+  void set_error(std::exception_ptr) noexcept {}
 
   [[nodiscard]]
-  ex::env<> get_env() const noexcept {
+  ex::env<> get_env() const noexcept
+  {
     return {};
   }
 };
 
-TEST_CASE("receiver types satisfy the receiver concept", "[concepts][receiver]") {
+TEST_CASE("receiver types satisfy the receiver concept", "[concepts][receiver]")
+{
   using namespace empty_recv;
 
   REQUIRE(ex::receiver<recv0>);
@@ -140,7 +140,8 @@ TEST_CASE("receiver types satisfy the receiver concept", "[concepts][receiver]")
   REQUIRE(ex::receiver<logging_receiver>);
 }
 
-TEST_CASE("receiver types satisfy the receiver_of concept", "[concepts][receiver]") {
+TEST_CASE("receiver types satisfy the receiver_of concept", "[concepts][receiver]")
+{
   using namespace empty_recv;
 
   REQUIRE(ex::receiver_of<recv_int, ex::completion_signatures<ex::set_value_t(int)>>);
@@ -148,43 +149,35 @@ TEST_CASE("receiver types satisfy the receiver_of concept", "[concepts][receiver
   REQUIRE(
     ex::receiver_of<recv_int_ec, ex::completion_signatures<ex::set_error_t(std::error_code)>>);
   REQUIRE(ex::receiver_of<recv_int_ec, ex::completion_signatures<ex::set_value_t(int)>>);
-  REQUIRE(
-    ex::receiver_of<
-      expect_value_receiver<ex::env<>, int>,
-      ex::completion_signatures<ex::set_value_t(int)>
-    >);
-  REQUIRE(
-    ex::receiver_of<
-      expect_value_receiver<ex::env<>, double>,
-      ex::completion_signatures<ex::set_value_t(double)>
-    >);
+  REQUIRE(ex::receiver_of<expect_value_receiver<ex::env<>, int>,
+                          ex::completion_signatures<ex::set_value_t(int)>>);
+  REQUIRE(ex::receiver_of<expect_value_receiver<ex::env<>, double>,
+                          ex::completion_signatures<ex::set_value_t(double)>>);
   REQUIRE(
     ex::receiver_of<expect_stopped_receiver<>, ex::completion_signatures<ex::set_value_t(char)>>);
-  REQUIRE(
-    ex::receiver_of<expect_stopped_receiver_ex<>, ex::completion_signatures<ex::set_value_t(char)>>);
+  REQUIRE(ex::receiver_of<expect_stopped_receiver_ex<>,
+                          ex::completion_signatures<ex::set_value_t(char)>>);
   REQUIRE(
     ex::receiver_of<expect_error_receiver<>, ex::completion_signatures<ex::set_value_t(char)>>);
-  REQUIRE(
-    ex::receiver_of<
-      expect_error_receiver_ex<std::error_code>,
-      ex::completion_signatures<ex::set_value_t(char)>
-    >);
+  REQUIRE(ex::receiver_of<expect_error_receiver_ex<std::error_code>,
+                          ex::completion_signatures<ex::set_value_t(char)>>);
   REQUIRE(ex::receiver_of<logging_receiver, ex::completion_signatures<ex::set_value_t(char)>>);
 }
 
-TEST_CASE(
-  "receiver type w/o set_value models receiver but not receiver_of",
-  "[concepts][receiver]") {
+TEST_CASE("receiver type w/o set_value models receiver but not receiver_of", "[concepts][receiver]")
+{
   REQUIRE(ex::receiver<recv_no_set_value>);
   REQUIRE(!ex::receiver_of<recv_no_set_value, ex::completion_signatures<ex::set_value_t()>>);
 }
 
-TEST_CASE("type with set_value noexcept is a receiver", "[concepts][receiver]") {
+TEST_CASE("type with set_value noexcept is a receiver", "[concepts][receiver]")
+{
   REQUIRE(ex::receiver<recv_set_value_noexcept>);
   REQUIRE(ex::receiver_of<recv_set_value_noexcept, ex::completion_signatures<ex::set_value_t()>>);
 }
 
-TEST_CASE("non-movable type is not a receiver", "[concepts][receiver]") {
+TEST_CASE("non-movable type is not a receiver", "[concepts][receiver]")
+{
   REQUIRE(!ex::receiver<recv_non_movable>);
   REQUIRE(!ex::receiver_of<recv_non_movable, ex::completion_signatures<ex::set_value_t()>>);
 }
diff --git a/test/stdexec/concepts/test_concepts_scope_association.cpp b/test/stdexec/concepts/test_concepts_scope_association.cpp
index a439344a8..b59268d8a 100644
--- a/test/stdexec/concepts/test_concepts_scope_association.cpp
+++ b/test/stdexec/concepts/test_concepts_scope_association.cpp
@@ -20,73 +20,88 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
   // a "null" association that is always truthy and for which try_associate() always succeeds
-  struct null_association {
+  struct null_association
+  {
     // this need not be explicit, although it should be
-    constexpr operator bool() const noexcept {
+    constexpr operator bool() const noexcept
+    {
       return true;
     }
 
     // this may throw, although it need not
-    constexpr null_association try_associate() const noexcept {
+    constexpr null_association try_associate() const noexcept
+    {
       return {};
     }
   };
 
   // a CRTP base that lets us produce variations on null_associaton with the right return type on try_associate
   template <class Derived>
-  struct crtp_association : null_association {
-    constexpr Derived try_associate() const noexcept {
+  struct crtp_association : null_association
+  {
+    constexpr Derived try_associate() const noexcept
+    {
       return {};
     }
   };
 
-  struct throwing_specials : crtp_association<throwing_specials> {
+  struct throwing_specials : crtp_association<throwing_specials>
+  {
     // it's ok for the non-move operators to throw
-    throwing_specials() noexcept(false) {
+    throwing_specials() noexcept(false)
+    {
       // nvcc doesn't respect the noexcept(false) with = default
     }
-    throwing_specials(const throwing_specials&) noexcept(false) {
+    throwing_specials(throwing_specials const &) noexcept(false)
+    {
       // nvcc doesn't respect the noexcept(false) with = default
     }
     throwing_specials(throwing_specials&&) noexcept = default;
-    ~throwing_specials() = default;
+    ~throwing_specials()                            = default;
 
-    throwing_specials& operator=(const throwing_specials&) noexcept(false) {
+    throwing_specials& operator=(throwing_specials const &) noexcept(false)
+    {
       // nvcc doesn't respect the noexcept(false) with = default
       return *this;
     }
     throwing_specials& operator=(throwing_specials&&) noexcept = default;
   };
 
-  struct move_only : crtp_association<move_only> {
+  struct move_only : crtp_association<move_only>
+  {
     // copy operations are not required
-    move_only() = default;
+    move_only()            = default;
     move_only(move_only&&) = default;
-    ~move_only() = default;
+    ~move_only()           = default;
 
     move_only& operator=(move_only&&) = default;
   };
 
-  struct explicit_bool : crtp_association<explicit_bool> {
+  struct explicit_bool : crtp_association<explicit_bool>
+  {
     // the bool conversion may be explicit
-    constexpr explicit operator bool() const noexcept {
+    constexpr explicit operator bool() const noexcept
+    {
       return true;
     }
   };
 
-  struct throwing_reassociate : crtp_association<throwing_reassociate> {
+  struct throwing_reassociate : crtp_association<throwing_reassociate>
+  {
     // try_associate may throw
-    constexpr throwing_reassociate try_associate() const noexcept(false) {
+    constexpr throwing_reassociate try_associate() const noexcept(false)
+    {
       return {};
     }
   };
 
-  TEST_CASE(
-    "Scope association concept accepts basic association types",
-    "[concepts][scope_association]") {
+  TEST_CASE("Scope association concept accepts basic association types",
+            "[concepts][scope_association]")
+  {
     // scope_association should accept the basic null_association
     STATIC_REQUIRE(ex::scope_association<null_association>);
 
@@ -94,8 +109,8 @@ namespace {
     STATIC_REQUIRE(ex::scope_association<throwing_specials>);
     // double check that we're testing what we think we are
     STATIC_REQUIRE(!ex::__nothrow_constructible_from<throwing_specials>);
-    STATIC_REQUIRE(!ex::__nothrow_constructible_from<throwing_specials, const throwing_specials&>);
-    STATIC_REQUIRE(!ex::__nothrow_assignable_from<throwing_specials, const throwing_specials&>);
+    STATIC_REQUIRE(!ex::__nothrow_constructible_from<throwing_specials, throwing_specials const &>);
+    STATIC_REQUIRE(!ex::__nothrow_assignable_from<throwing_specials, throwing_specials const &>);
 
     // copy operations are not required
     STATIC_REQUIRE(ex::scope_association<move_only>);
@@ -108,20 +123,24 @@ namespace {
   }
 
   // invalid association because of immovability
-  struct immovable : crtp_association<immovable> {
+  struct immovable : crtp_association<immovable>
+  {
     immovable(immovable&&) = delete;
   };
 
   // conditionally-invalid association because of throwing move operations
   template <bool ThrowingCtor, bool ThrowingAssign>
-  struct throwing_moves : crtp_association<throwing_moves<ThrowingCtor, ThrowingAssign>> {
+  struct throwing_moves : crtp_association<throwing_moves<ThrowingCtor, ThrowingAssign>>
+  {
     throwing_moves() = default;
-    throwing_moves(throwing_moves&&) noexcept(ThrowingCtor) {
+    throwing_moves(throwing_moves&&) noexcept(ThrowingCtor)
+    {
       // nvcc doesn't respect the noexcept(false) with = default
     }
     ~throwing_moves() = default;
 
-    throwing_moves& operator=(throwing_moves&&) noexcept(ThrowingAssign) {
+    throwing_moves& operator=(throwing_moves&&) noexcept(ThrowingAssign)
+    {
       // nvcc doesn't respect the noexcept(false) with = default
       return *this;
     }
@@ -133,37 +152,45 @@ namespace {
   using throwing_move_assign = throwing_moves<false, true>;
 
   // invalid assocation because of a missing default constructor
-  struct missing_ctor : crtp_association<missing_ctor> {
+  struct missing_ctor : crtp_association<missing_ctor>
+  {
     missing_ctor() = delete;
   };
 
   // invalid assocation because of a throwing conversion to bool
-  struct throwing_boolish : crtp_association<throwing_boolish> {
-    constexpr explicit operator bool() const noexcept(false) {
+  struct throwing_boolish : crtp_association<throwing_boolish>
+  {
+    constexpr explicit operator bool() const noexcept(false)
+    {
       return true;
     }
   };
 
   // invalid assocation because try_associate returns the wrong type
-  struct cannot_reassociate : null_association { };
+  struct cannot_reassociate : null_association
+  {};
 
   // invalid association because operator bool is non-const
-  struct non_const_boolish : crtp_association<non_const_boolish> {
-    constexpr explicit operator bool() noexcept {
+  struct non_const_boolish : crtp_association<non_const_boolish>
+  {
+    constexpr explicit operator bool() noexcept
+    {
       return true;
     }
   };
 
   // invalid association because try_associate is non-const
-  struct non_const_try_associate : null_association {
-    constexpr non_const_try_associate try_associate() noexcept {
+  struct non_const_try_associate : null_association
+  {
+    constexpr non_const_try_associate try_associate() noexcept
+    {
       return {};
     };
   };
 
-  TEST_CASE(
-    "Scope association concept rejects non-association types",
-    "[concepts][scope_association]") {
+  TEST_CASE("Scope association concept rejects non-association types",
+            "[concepts][scope_association]")
+  {
     STATIC_REQUIRE(!ex::scope_association<int>);
 
     // movability is required
@@ -188,4 +215,4 @@ namespace {
     // try_associate must be const qualified
     STATIC_REQUIRE(!ex::scope_association<non_const_try_associate>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/concepts/test_concepts_scope_token.cpp b/test/stdexec/concepts/test_concepts_scope_token.cpp
index e4cb3f96d..a200d187f 100644
--- a/test/stdexec/concepts/test_concepts_scope_token.cpp
+++ b/test/stdexec/concepts/test_concepts_scope_token.cpp
@@ -20,9 +20,11 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("Scope token helpers are correctly defined", "[concepts][scope_token]") {
+  TEST_CASE("Scope token helpers are correctly defined", "[concepts][scope_token]")
+  {
     // check the test-sender and test-env definitions are appropriate
     STATIC_REQUIRE(ex::sender<ex::__scope_concepts::__test_sender>);
     STATIC_REQUIRE(ex::sender_in<ex::__scope_concepts::__test_sender, ex::env<>>);
@@ -30,62 +32,76 @@ namespace {
   }
 
   // a "null" token that can always create new associations
-  struct null_token {
+  struct null_token
+  {
     // the always-truthy association type
-    struct assoc {
+    struct assoc
+    {
       // this need not be explicit, although it should be
-      constexpr operator bool() const noexcept {
+      constexpr operator bool() const noexcept
+      {
         return true;
       }
 
       // this may throw, although it need not
-      constexpr assoc try_associate() const noexcept {
+      constexpr assoc try_associate() const noexcept
+      {
         return {};
       }
     };
 
-    constexpr assoc try_associate() const noexcept {
+    constexpr assoc try_associate() const noexcept
+    {
       return {};
     }
 
     template <ex::sender Sender>
-    Sender&& wrap(Sender&& snd) const noexcept {
+    Sender&& wrap(Sender&& snd) const noexcept
+    {
       return std::forward<Sender>(snd);
     }
   };
 
-  struct throwing_try_associate : null_token {
-    constexpr assoc try_associate() const noexcept(false) {
+  struct throwing_try_associate : null_token
+  {
+    constexpr assoc try_associate() const noexcept(false)
+    {
       return {};
     }
   };
 
-  struct throwing_wrap : null_token {
+  struct throwing_wrap : null_token
+  {
     template <ex::sender Sender>
-    constexpr Sender&& wrap(Sender&& snd) const noexcept(false) {
+    constexpr Sender&& wrap(Sender&& snd) const noexcept(false)
+    {
       return std::forward<Sender>(snd);
     }
   };
 
-  struct wrapping_wrap : null_token {
+  struct wrapping_wrap : null_token
+  {
     template <ex::sender Sender>
-    struct wrapper : Sender {
-      wrapper(const Sender& snd)
-        : Sender(snd) {
-      }
+    struct wrapper : Sender
+    {
+      wrapper(Sender const & snd)
+        : Sender(snd)
+      {}
 
       wrapper(Sender&& snd)
-        : Sender(std::move(snd)) {
-      }
+        : Sender(std::move(snd))
+      {}
     };
 
     template <ex::sender Sender>
-    auto wrap(Sender&& snd) const noexcept {
+    auto wrap(Sender&& snd) const noexcept
+    {
       return wrapper{std::forward<Sender>(snd)};
     }
   };
 
-  TEST_CASE("Scope token concept accepts basic token types", "[concepts][scope_token]") {
+  TEST_CASE("Scope token concept accepts basic token types", "[concepts][scope_token]")
+  {
     // scope_token should accept the basic null_token
     STATIC_REQUIRE(ex::scope_token<null_token>);
 
@@ -99,28 +115,34 @@ namespace {
     STATIC_REQUIRE(ex::scope_token<wrapping_wrap>);
   }
 
-  struct move_only : null_token {
-    move_only() = default;
+  struct move_only : null_token
+  {
+    move_only()            = default;
     move_only(move_only&&) = default;
-    ~move_only() = default;
+    ~move_only()           = default;
 
     move_only& operator=(move_only&&) = default;
   };
 
-  struct non_const_try_associate : null_token {
-    assoc try_associate() noexcept {
+  struct non_const_try_associate : null_token
+  {
+    assoc try_associate() noexcept
+    {
       return {};
     }
   };
 
-  struct non_const_wrap : null_token {
+  struct non_const_wrap : null_token
+  {
     template <ex::sender Sender>
-    Sender&& wrap(Sender&& snd) noexcept {
+    Sender&& wrap(Sender&& snd) noexcept
+    {
       return std::forward<Sender>(snd);
     }
   };
 
-  TEST_CASE("Scope token concept rejects non-token types", "[concepts][scope_token]") {
+  TEST_CASE("Scope token concept rejects non-token types", "[concepts][scope_token]")
+  {
     STATIC_REQUIRE(!ex::scope_token<int>);
 
     // tokens must be copyable
@@ -132,4 +154,4 @@ namespace {
     // wrap must be const-qualified
     STATIC_REQUIRE(!ex::scope_token<non_const_wrap>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/concepts/test_concepts_sender.cpp b/test/stdexec/concepts/test_concepts_sender.cpp
index 571ae9a81..bc15b901e 100644
--- a/test/stdexec/concepts/test_concepts_sender.cpp
+++ b/test/stdexec/concepts/test_concepts_sender.cpp
@@ -25,99 +25,117 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-namespace {
-  struct not_a_sender { };
+namespace
+{
+  struct not_a_sender
+  {};
 
-  TEST_CASE("Sender concept rejects non-sender types", "[concepts][sender]") {
+  TEST_CASE("Sender concept rejects non-sender types", "[concepts][sender]")
+  {
     STATIC_REQUIRE(!ex::sender<int>);
     STATIC_REQUIRE(!ex::sender<not_a_sender>);
   }
 
-  struct P2300r7_sender_1 {
+  struct P2300r7_sender_1
+  {
     using sender_concept = STDEXEC::sender_t;
   };
 
-  struct P2300r7_sender_2 { };
-} // namespace
+  struct P2300r7_sender_2
+  {};
+}  // namespace
 
 template <>
 inline constexpr bool STDEXEC::enable_sender<P2300r7_sender_2> = true;
 
-namespace {
+namespace
+{
 
-  TEST_CASE("Sender concept accepts P2300R7-style senders", "[concepts][sender]") {
+  TEST_CASE("Sender concept accepts P2300R7-style senders", "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender<P2300r7_sender_1>);
     STATIC_REQUIRE(ex::sender<P2300r7_sender_2>);
   }
 
 #if !STDEXEC_NO_STD_COROUTINES()
-  struct an_awaiter {
+  struct an_awaiter
+  {
     auto await_ready() -> bool;
     void await_suspend(STDEXEC::__std::coroutine_handle<>);
     void await_resume();
   };
 
-  struct an_awaitable {
-    friend auto operator co_await(an_awaitable) -> an_awaiter {
+  struct an_awaitable
+  {
+    friend auto operator co_await(an_awaitable) -> an_awaiter
+    {
       return {};
     }
   };
 
-  struct has_as_awaitable {
+  struct has_as_awaitable
+  {
     template <class Promise>
-    auto as_awaitable(Promise&) const -> an_awaitable {
+    auto as_awaitable(Promise&) const -> an_awaitable
+    {
       return {};
     }
   };
 
-  TEST_CASE("Sender concept accepts awaiters and awaitables", "[concepts][sender]") {
+  TEST_CASE("Sender concept accepts awaiters and awaitables", "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender<an_awaiter>);
     STATIC_REQUIRE(ex::sender<an_awaitable>);
     STATIC_REQUIRE(ex::sender<has_as_awaitable>);
   }
 #endif
 
-  struct oper {
-    oper() = default;
+  struct oper
+  {
+    oper()       = default;
     oper(oper&&) = delete;
 
-    void start() & noexcept {
-    }
+    void start() & noexcept {}
   };
 
-  struct my_sender0 {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(),
-      ex::set_error_t(std::exception_ptr),
-      ex::set_stopped_t()
-    >;
+  struct my_sender0
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                            ex::set_error_t(std::exception_ptr),
+                                                            ex::set_stopped_t()>;
 
-    auto connect(empty_recv::recv0&&) const -> oper {
+    auto connect(empty_recv::recv0&&) const -> oper
+    {
       return {};
     }
   };
 
-  struct void_sender {
-    using sender_concept = STDEXEC::sender_t;
+  struct void_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t()>;
 
     template <class Receiver>
-    auto connect(Receiver) -> oper {
+    auto connect(Receiver) -> oper
+    {
       return {};
     }
   };
 
-  struct invalid_receiver {
+  struct invalid_receiver
+  {
     using receiver_concept = STDEXEC::receiver_t;
 
     template <class... As>
-    void set_value(As&&...) noexcept {
-      static_assert(sizeof...(As) == ~size_t(0)); // hard error always
+    void set_value(As&&...) noexcept
+    {
+      static_assert(sizeof...(As) == ~size_t(0));  // hard error always
     }
   };
 
-  TEST_CASE("type w/ proper types, is a sender", "[concepts][sender]") {
+  TEST_CASE("type w/ proper types, is a sender", "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender<my_sender0>);
     STATIC_REQUIRE(ex::sender_in<my_sender0, ex::env<>>);
 
@@ -129,47 +147,48 @@ namespace {
     STATIC_REQUIRE(ex::sender_of<my_sender0, ex::set_stopped_t(), ex::env<>>);
   }
 
-  TEST_CASE(
-    "sender_to concept does not instantiate the receiver's completion functions",
-    "[concepts][sender]") {
+  TEST_CASE("sender_to concept does not instantiate the receiver's completion functions",
+            "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender_to<void_sender, invalid_receiver>);
   }
 
-  TEST_CASE(
-    "sender that accepts a void sender models sender_to the given sender",
-    "[concepts][sender]") {
+  TEST_CASE("sender that accepts a void sender models sender_to the given sender",
+            "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender_to<my_sender0, empty_recv::recv0>);
   }
 
-  struct my_sender_int {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(int),
-      ex::set_error_t(std::exception_ptr),
-      ex::set_stopped_t()
-    >;
+  struct my_sender_int
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(int),
+                                                            ex::set_error_t(std::exception_ptr),
+                                                            ex::set_stopped_t()>;
 
-    auto connect(empty_recv::recv_int&&) const -> oper {
+    auto connect(empty_recv::recv_int&&) const -> oper
+    {
       return {};
     }
   };
 
-  TEST_CASE("my_sender_int is a sender", "[concepts][sender]") {
+  TEST_CASE("my_sender_int is a sender", "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender<my_sender_int>);
     STATIC_REQUIRE(ex::sender_in<my_sender_int, ex::env<>>);
     STATIC_REQUIRE(ex::sender_of<my_sender_int, ex::set_value_t(int)>);
     STATIC_REQUIRE(ex::sender_of<my_sender_int, ex::set_value_t(int), ex::env<>>);
   }
 
-  TEST_CASE(
-    "sender that accepts an int receiver models sender_to the given receiver",
-    "[concepts][sender]") {
+  TEST_CASE("sender that accepts an int receiver models sender_to the given receiver",
+            "[concepts][sender]")
+  {
     STATIC_REQUIRE(ex::sender_to<my_sender_int, empty_recv::recv_int>);
   }
 
-  TEST_CASE(
-    "not all combinations of senders & receivers satisfy the sender_to concept",
-    "[concepts][sender]") {
+  TEST_CASE("not all combinations of senders & receivers satisfy the sender_to concept",
+            "[concepts][sender]")
+  {
     REQUIRE_FALSE(ex::sender_to<my_sender0, empty_recv::recv_int>);
     REQUIRE_FALSE(ex::sender_to<my_sender0, empty_recv::recv0_ec>);
     REQUIRE_FALSE(ex::sender_to<my_sender0, empty_recv::recv_int_ec>);
@@ -178,134 +197,142 @@ namespace {
     REQUIRE_FALSE(ex::sender_to<my_sender_int, empty_recv::recv_int_ec>);
   }
 
-  TEST_CASE(
-    "can query completion signatures for a typed sender that sends nothing",
-    "[concepts][sender]") {
+  TEST_CASE("can query completion signatures for a typed sender that sends nothing",
+            "[concepts][sender]")
+  {
     check_val_types<ex::__mset<pack<>>>(my_sender0{});
     check_err_types<ex::__mset<std::exception_ptr>>(my_sender0{});
     check_sends_stopped<true>(my_sender0{});
     STATIC_REQUIRE(ex::sender_of<my_sender0, ex::set_value_t()>);
   }
 
-  TEST_CASE(
-    "can query completion signatures for a typed sender that sends int",
-    "[concepts][sender]") {
+  TEST_CASE("can query completion signatures for a typed sender that sends int",
+            "[concepts][sender]")
+  {
     check_val_types<ex::__mset<pack<int>>>(my_sender_int{});
     check_err_types<ex::__mset<std::exception_ptr>>(my_sender_int{});
     check_sends_stopped<true>(my_sender_int{});
     STATIC_REQUIRE(ex::sender_of<my_sender_int, ex::set_value_t(int)>);
   }
 
-  struct multival_sender {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(int, double),
-      ex::set_value_t(short, long),
-      ex::set_error_t(std::exception_ptr)
-    >;
+  struct multival_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(int, double),
+                                                            ex::set_value_t(short, long),
+                                                            ex::set_error_t(std::exception_ptr)>;
 
-    auto connect(empty_recv::recv_int&&) const -> oper {
+    auto connect(empty_recv::recv_int&&) const -> oper
+    {
       return {};
     }
   };
 
-  TEST_CASE(
-    "check completion signatures for sender that advertises multiple sets of values",
-    "[concepts][sender]") {
+  TEST_CASE("check completion signatures for sender that advertises multiple sets of values",
+            "[concepts][sender]")
+  {
     check_val_types<ex::__mset<pack<int, double>, pack<short, long>>>(multival_sender{});
     check_err_types<ex::__mset<std::exception_ptr>>(multival_sender{});
     check_sends_stopped<false>(multival_sender{});
     REQUIRE_FALSE(ex::sender_of<multival_sender, ex::set_value_t(int, double)>);
   }
 
-  struct ec_sender {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(),
-      ex::set_error_t(std::exception_ptr),
-      ex::set_error_t(int)
-    >;
+  struct ec_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                            ex::set_error_t(std::exception_ptr),
+                                                            ex::set_error_t(int)>;
 
-    auto connect(empty_recv::recv_int&&) const -> oper {
+    auto connect(empty_recv::recv_int&&) const -> oper
+    {
       return {};
     }
   };
 
-  TEST_CASE(
-    "check completion signatures for sender that also supports error codes",
-    "[concepts][sender]") {
+  TEST_CASE("check completion signatures for sender that also supports error codes",
+            "[concepts][sender]")
+  {
     check_val_types<ex::__mset<pack<>>>(ec_sender{});
     check_err_types<ex::__mset<std::exception_ptr, int>>(ec_sender{});
     check_sends_stopped<false>(ec_sender{});
     STATIC_REQUIRE(ex::sender_of<ec_sender, ex::set_value_t()>);
   }
 
-  struct my_r5_sender0 {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(),
-      ex::set_error_t(std::exception_ptr),
-      ex::set_stopped_t()
-    >;
+  struct my_r5_sender0
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                            ex::set_error_t(std::exception_ptr),
+                                                            ex::set_stopped_t()>;
 
-    auto connect(empty_recv::recv0&&) const -> oper {
+    auto connect(empty_recv::recv0&&) const -> oper
+    {
       return {};
     }
   };
 
-  TEST_CASE("r5 sender emits deprecated diagnostics", "[concepts][sender]") {
+  TEST_CASE("r5 sender emits deprecated diagnostics", "[concepts][sender]")
+  {
     void(ex::get_env(my_r5_sender0{}));
     static_assert(ex::sender<my_r5_sender0>);
-    static_assert(std::same_as<
-                  decltype(ex::get_completion_signatures(my_r5_sender0{}, ex::env<>{})),
-                  my_r5_sender0::completion_signatures
-    >);
+    static_assert(
+      std::same_as<decltype(ex::get_completion_signatures(my_r5_sender0{}, ex::env<>{})),
+                   my_r5_sender0::completion_signatures>);
   }
 
 #if !STDEXEC_NVHPC()
   // nvc++ doesn't yet implement subsumption correctly
-  struct not_a_sender_tag { };
+  struct not_a_sender_tag
+  {};
 
-  struct sender_tag { };
+  struct sender_tag
+  {};
 
-  struct sender_env_tag { };
+  struct sender_env_tag
+  {};
 
-  struct sender_of_tag { };
+  struct sender_of_tag
+  {};
 
   template <class T>
-  auto test_subsumption(T&&) -> not_a_sender_tag {
+  auto test_subsumption(T&&) -> not_a_sender_tag
+  {
     return {};
   }
 
   template <ex::sender T>
-  auto test_subsumption(T&&) -> sender_tag {
+  auto test_subsumption(T&&) -> sender_tag
+  {
     return {};
   }
 
   template <ex::sender_in<ex::env<>> T>
-  auto test_subsumption(T&&) -> sender_env_tag {
+  auto test_subsumption(T&&) -> sender_env_tag
+  {
     return {};
   }
 
   template <ex::sender_of<ex::set_value_t(), ex::env<>> T>
-  auto test_subsumption(T&&) -> sender_of_tag {
+  auto test_subsumption(T&&) -> sender_of_tag
+  {
     return {};
   }
 
   template <class Expected, class T>
-  void has_type(T&&) {
+  void has_type(T&&)
+  {
     STATIC_REQUIRE(std::same_as<T, Expected>);
   }
 
-  TEST_CASE(
-    "check for subsumption relationships between the sender concepts",
-    "[concepts][sender]") {
+  TEST_CASE("check for subsumption relationships between the sender concepts", "[concepts][sender]")
+  {
     ::has_type<not_a_sender_tag>(::test_subsumption(42));
     ::has_type<sender_tag>(::test_subsumption(ex::get_scheduler()));
     ::has_type<sender_env_tag>(::test_subsumption(ex::just(42)));
     ::has_type<sender_of_tag>(::test_subsumption(ex::just()));
   }
 #endif
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/concepts/test_concepts_stop_tokens.cpp b/test/stdexec/concepts/test_concepts_stop_tokens.cpp
index 13c6228e9..4a434d3ce 100644
--- a/test/stdexec/concepts/test_concepts_stop_tokens.cpp
+++ b/test/stdexec/concepts/test_concepts_stop_tokens.cpp
@@ -20,27 +20,25 @@
 
 #include <type_traits>
 
-namespace {
+namespace
+{
 
-  struct on_stop_request {
-    void operator()() && noexcept {
-    }
+  struct on_stop_request
+  {
+    void operator()() && noexcept {}
   };
 
   static_assert(::STDEXEC::stoppable_token<::STDEXEC::never_stop_token>);
   static_assert(::STDEXEC::unstoppable_token<::STDEXEC::never_stop_token>);
   static_assert(::STDEXEC::stoppable_token<::STDEXEC::inplace_stop_token>);
   static_assert(!::STDEXEC::unstoppable_token<::STDEXEC::inplace_stop_token>);
-  static_assert(std::is_same_v<
-                ::STDEXEC::stop_callback_for_t<::STDEXEC::never_stop_token, on_stop_request>,
-                ::STDEXEC::never_stop_token::callback_type<on_stop_request>
-  >);
+  static_assert(
+    std::is_same_v<::STDEXEC::stop_callback_for_t<::STDEXEC::never_stop_token, on_stop_request>,
+                   ::STDEXEC::never_stop_token::callback_type<on_stop_request>>);
 
 #if defined(__cpp_lib_jthread) && __cpp_lib_jthread >= 2019'11L
   static_assert(::STDEXEC::stoppable_token<std::stop_token>);
-  static_assert(std::is_same_v<
-                ::STDEXEC::stop_callback_for_t<std::stop_token, on_stop_request>,
-                std::stop_callback<on_stop_request>
-  >);
+  static_assert(std::is_same_v<::STDEXEC::stop_callback_for_t<std::stop_token, on_stop_request>,
+                               std::stop_callback<on_stop_request>>);
 #endif
-} // namespace
+}  // namespace
diff --git a/test/stdexec/cpos/test_cpo_bulk.cpp b/test/stdexec/cpos/test_cpo_bulk.cpp
index 7fa03717d..2a5e0f2f8 100644
--- a/test/stdexec/cpos/test_cpo_bulk.cpp
+++ b/test/stdexec/cpos/test_cpo_bulk.cpp
@@ -18,28 +18,31 @@
 #include "test_common/receivers.hpp"
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("bulk is customizable", "[cpo][cpo_bulk]") {
-    const auto n = 42;
-    const auto f = [](int) {
+  TEST_CASE("bulk is customizable", "[cpo][cpo_bulk]")
+  {
+    auto const n = 42;
+    auto const f = [](int) {
     };
 
-    SECTION("by completion scheduler domain") {
+    SECTION("by completion scheduler domain")
+    {
       cpo_test_scheduler_t<ex::bulk_t>::sender_t snd{};
 
       {
-        constexpr scope_t scope = decltype(ex::connect(
-          snd | ex::bulk(ex::par, n, f), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(snd | ex::bulk(ex::par, n, f),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
 
       {
         void(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(snd)));
-        constexpr scope_t scope = decltype(ex::connect(
-          ex::bulk(snd, ex::par, n, f), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(ex::bulk(snd, ex::par, n, f),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/cpos/test_cpo_connect.cpp b/test/stdexec/cpos/test_cpo_connect.cpp
index 4c52da695..c04c522b7 100644
--- a/test/stdexec/cpos/test_cpo_connect.cpp
+++ b/test/stdexec/cpos/test_cpo_connect.cpp
@@ -25,58 +25,68 @@ STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunneeded-internal-declaration")
 
-namespace {
+namespace
+{
 
   template <typename R>
-  struct op_state : immovable {
+  struct op_state : immovable
+  {
     int val_;
-    R recv_;
+    R   recv_;
 
-    void start() & noexcept {
+    void start() & noexcept
+    {
       ex::set_value(static_cast<R&&>(recv_), static_cast<int>(val_));
     }
   };
 
-  struct my_sender {
-    using sender_concept = STDEXEC::sender_t;
+  struct my_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t(int)>;
 
     int value_{0};
 
     template <class R>
     [[nodiscard]]
-    auto connect(R r) const -> op_state<R> {
+    auto connect(R r) const -> op_state<R>
+    {
       return {{}, value_, std::move(r)};
     }
   };
 
-  struct my_sender_unconstrained {
-    using sender_concept = STDEXEC::sender_t;
+  struct my_sender_unconstrained
+  {
+    using sender_concept        = STDEXEC::sender_t;
     using completion_signatures = ex::completion_signatures<ex::set_value_t(int)>;
 
     int value_{0};
 
-    template <class R> // accept any type here
+    template <class R>  // accept any type here
     [[nodiscard]]
-    auto connect(R r) const -> op_state<R> {
+    auto connect(R r) const -> op_state<R>
+    {
       return {{}, value_, std::move(r)};
     }
   };
 
-  TEST_CASE("can call connect on an appropriate types", "[cpo][cpo_connect]") {
+  TEST_CASE("can call connect on an appropriate types", "[cpo][cpo_connect]")
+  {
     auto op = ex::connect(my_sender{10}, expect_value_receiver{10});
     ex::start(op);
     // the receiver will check the received value
   }
 
-  TEST_CASE("cannot connect sender with invalid receiver", "[cpo][cpo_connect]") {
+  TEST_CASE("cannot connect sender with invalid receiver", "[cpo][cpo_connect]")
+  {
     static_assert(ex::sender<my_sender_unconstrained>);
     REQUIRE_FALSE(ex::sender_to<my_sender_unconstrained, int>);
   }
 
-  TEST_CASE("tag types can be deduced from ex::connect", "[cpo][cpo_connect]") {
-    static_assert(std::is_same_v<const ex::connect_t, decltype(ex::connect)>, "type mismatch");
+  TEST_CASE("tag types can be deduced from ex::connect", "[cpo][cpo_connect]")
+  {
+    static_assert(std::is_same_v<ex::connect_t const, decltype(ex::connect)>, "type mismatch");
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/cpos/test_cpo_receiver.cpp b/test/stdexec/cpos/test_cpo_receiver.cpp
index 95c3c219f..b6fdb3366 100644
--- a/test/stdexec/cpos/test_cpo_receiver.cpp
+++ b/test/stdexec/cpos/test_cpo_receiver.cpp
@@ -26,209 +26,245 @@ namespace ex = STDEXEC;
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
-namespace {
+namespace
+{
 
-  struct recv_value {
+  struct recv_value
+  {
     int* target_;
 
-    void set_value(int val) noexcept {
+    void set_value(int val) noexcept
+    {
       *target_ = val;
     }
 
-    void set_error(int ec) noexcept {
+    void set_error(int ec) noexcept
+    {
       *target_ = -ec;
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       *target_ = INT_MAX;
     }
   };
 
-  struct recv_rvalref {
+  struct recv_rvalref
+  {
     int* target_;
 
-    void set_value(int val) noexcept {
+    void set_value(int val) noexcept
+    {
       *target_ = val;
     }
 
-    void set_error(int ec) noexcept {
+    void set_error(int ec) noexcept
+    {
       *target_ = -ec;
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       *target_ = INT_MAX;
     }
   };
 
-  struct recv_ref {
+  struct recv_ref
+  {
     int* target_;
 
-    void set_value(int val) noexcept {
+    void set_value(int val) noexcept
+    {
       *target_ = val;
     }
 
-    void set_error(int ec) noexcept {
+    void set_error(int ec) noexcept
+    {
       *target_ = -ec;
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       *target_ = INT_MAX;
     }
   };
 
-  struct recv_cref {
+  struct recv_cref
+  {
     int* target_;
 
-    void set_value(int val) noexcept {
+    void set_value(int val) noexcept
+    {
       *target_ = val;
     }
 
-    void set_error(int ec) noexcept {
+    void set_error(int ec) noexcept
+    {
       *target_ = -ec;
     }
 
-    void set_stopped() noexcept {
+    void set_stopped() noexcept
+    {
       *target_ = INT_MAX;
     }
   };
 
-  TEST_CASE("can call set_value on a void receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_value on a void receiver", "[cpo][cpo_receiver]")
+  {
     ex::set_value(expect_void_receiver{});
   }
 
-  TEST_CASE("can call set_value on a int receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_value on a int receiver", "[cpo][cpo_receiver]")
+  {
     ex::set_value(expect_value_receiver{10}, 10);
   }
 
-  TEST_CASE("can call set_value on a string receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_value on a string receiver", "[cpo][cpo_receiver]")
+  {
     ex::set_value(expect_value_receiver{std::string{"hello"}}, std::string{"hello"});
   }
 
-  TEST_CASE("can call set_stopped on a receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_stopped on a receiver", "[cpo][cpo_receiver]")
+  {
     ex::set_stopped(expect_stopped_receiver{});
   }
 
-  TEST_CASE("can call set_error on a receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_error on a receiver", "[cpo][cpo_receiver]")
+  {
     std::exception_ptr ex = std::make_exception_ptr(std::bad_alloc{});
     ex::set_error(expect_error_receiver{}, ex);
   }
 
-  TEST_CASE("can call set_error with an error code on a receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("can call set_error with an error code on a receiver", "[cpo][cpo_receiver]")
+  {
     std::error_code errCode{100, std::generic_category()};
     ex::set_error(expect_error_receiver{errCode}, errCode);
   }
 
-  TEST_CASE("set_value with a value passes the value to the receiver", "[cpo][cpo_receiver]") {
+  TEST_CASE("set_value with a value passes the value to the receiver", "[cpo][cpo_receiver]")
+  {
     ex::set_value(expect_value_receiver{10}, 10);
   }
 
-  TEST_CASE("can call set_value on a receiver with plain value type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_value_t, recv_value, int>, "cannot call set_value on recv_value");
+  TEST_CASE("can call set_value on a receiver with plain value type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_value_t, recv_value, int>,
+                  "cannot call set_value on recv_value");
     int val = 0;
     ex::set_value(recv_value{&val}, 10);
     REQUIRE(val == 10);
   }
 
-  TEST_CASE("can call set_value on a receiver with r-value ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_value_t, recv_rvalref, int>, "cannot call set_value on recv_rvalref");
+  TEST_CASE("can call set_value on a receiver with r-value ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_value_t, recv_rvalref, int>,
+                  "cannot call set_value on recv_rvalref");
     int val = 0;
     ex::set_value(recv_rvalref{&val}, 10);
     REQUIRE(val == 10);
   }
 
-  TEST_CASE("can call set_value on a receiver with ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_value_t, recv_ref&, int>, "cannot call set_value on recv_ref");
-    int val = 0;
+  TEST_CASE("can call set_value on a receiver with ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_value_t, recv_ref&, int>,
+                  "cannot call set_value on recv_ref");
+    int      val = 0;
     recv_ref recv{&val};
     ex::set_value(recv, 10);
     REQUIRE(val == 10);
   }
 
-  TEST_CASE("can call set_value on a receiver with const ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_value_t, recv_cref, int>, "cannot call set_value on recv_cref");
+  TEST_CASE("can call set_value on a receiver with const ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_value_t, recv_cref, int>,
+                  "cannot call set_value on recv_cref");
     int val = 0;
     ex::set_value(recv_cref{&val}, 10);
     REQUIRE(val == 10);
   }
 
-  TEST_CASE("can call set_error on a receiver with plain value type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_error_t, recv_value, int>, "cannot call set_error on recv_value");
+  TEST_CASE("can call set_error on a receiver with plain value type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_error_t, recv_value, int>,
+                  "cannot call set_error on recv_value");
     int val = 0;
     ex::set_error(recv_value{&val}, 10);
     REQUIRE(val == -10);
   }
 
-  TEST_CASE("can call set_error on a receiver with r-value ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_error_t, recv_rvalref, int>, "cannot call set_error on recv_rvalref");
+  TEST_CASE("can call set_error on a receiver with r-value ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_error_t, recv_rvalref, int>,
+                  "cannot call set_error on recv_rvalref");
     int val = 0;
     ex::set_error(recv_rvalref{&val}, 10);
     REQUIRE(val == -10);
   }
 
-  TEST_CASE("can call set_error on a receiver with ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_error_t, recv_ref&, int>, "cannot call set_error on recv_ref");
-    int val = 0;
+  TEST_CASE("can call set_error on a receiver with ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_error_t, recv_ref&, int>,
+                  "cannot call set_error on recv_ref");
+    int      val = 0;
     recv_ref recv{&val};
     ex::set_error(recv, 10);
     REQUIRE(val == -10);
   }
 
-  TEST_CASE("can call set_error on a receiver with const ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_error_t, recv_cref, int>, "cannot call set_error on recv_cref");
+  TEST_CASE("can call set_error on a receiver with const ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_error_t, recv_cref, int>,
+                  "cannot call set_error on recv_cref");
     int val = 0;
     ex::set_error(recv_cref{&val}, 10);
     REQUIRE(val == -10);
   }
 
-  TEST_CASE("can call set_stopped on a receiver with plain value type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_stopped_t, recv_value>, "cannot call set_stopped on recv_value");
+  TEST_CASE("can call set_stopped on a receiver with plain value type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_stopped_t, recv_value>,
+                  "cannot call set_stopped on recv_value");
     int val = 0;
     ex::set_stopped(recv_value{&val});
     REQUIRE(val == INT_MAX);
   }
 
-  TEST_CASE("can call set_stopped on a receiver with r-value ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_stopped_t, recv_rvalref>, "cannot call set_stopped on recv_rvalref");
+  TEST_CASE("can call set_stopped on a receiver with r-value ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_stopped_t, recv_rvalref>,
+                  "cannot call set_stopped on recv_rvalref");
     int val = 0;
     ex::set_stopped(recv_rvalref{&val});
     REQUIRE(val == INT_MAX);
   }
 
-  TEST_CASE("can call set_stopped on a receiver with ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_stopped_t, recv_ref&>, "cannot call set_stopped on recv_ref");
-    int val = 0;
+  TEST_CASE("can call set_stopped on a receiver with ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_stopped_t, recv_ref&>,
+                  "cannot call set_stopped on recv_ref");
+    int      val = 0;
     recv_ref recv{&val};
     ex::set_stopped(recv);
     REQUIRE(val == INT_MAX);
   }
 
-  TEST_CASE("can call set_stopped on a receiver with const ref type", "[cpo][cpo_receiver]") {
-    static_assert(
-      std::invocable<ex::set_stopped_t, recv_cref>, "cannot call set_stopped on recv_cref");
+  TEST_CASE("can call set_stopped on a receiver with const ref type", "[cpo][cpo_receiver]")
+  {
+    static_assert(std::invocable<ex::set_stopped_t, recv_cref>,
+                  "cannot call set_stopped on recv_cref");
     int val = 0;
     ex::set_stopped(recv_cref{&val});
     REQUIRE(val == INT_MAX);
   }
 
-  TEST_CASE(
-    "tag types can be deduced from set_value, set_error and set_stopped",
-    "[cpo][cpo_receiver]") {
-    static_assert(std::is_same_v<const ex::set_value_t, decltype(ex::set_value)>, "type mismatch");
-    static_assert(std::is_same_v<const ex::set_error_t, decltype(ex::set_error)>, "type mismatch");
-    static_assert(
-      std::is_same_v<const ex::set_stopped_t, decltype(ex::set_stopped)>, "type mismatch");
+  TEST_CASE("tag types can be deduced from set_value, set_error and set_stopped",
+            "[cpo][cpo_receiver]")
+  {
+    static_assert(std::is_same_v<ex::set_value_t const, decltype(ex::set_value)>, "type mismatch");
+    static_assert(std::is_same_v<ex::set_error_t const, decltype(ex::set_error)>, "type mismatch");
+    static_assert(std::is_same_v<ex::set_stopped_t const, decltype(ex::set_stopped)>,
+                  "type mismatch");
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/cpos/test_cpo_schedule.cpp b/test/stdexec/cpos/test_cpo_schedule.cpp
index e3b321009..6311524e6 100644
--- a/test/stdexec/cpos/test_cpo_schedule.cpp
+++ b/test/stdexec/cpos/test_cpo_schedule.cpp
@@ -23,38 +23,42 @@ namespace ex = STDEXEC;
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
-namespace {
+namespace
+{
 
-  struct my_sender {
-    using sender_concept = STDEXEC::sender_t;
-    using completion_signatures = ex::completion_signatures<
-      ex::set_value_t(),
-      ex::set_error_t(std::exception_ptr),
-      ex::set_stopped_t()
-    >;
+  struct my_sender
+  {
+    using sender_concept        = STDEXEC::sender_t;
+    using completion_signatures = ex::completion_signatures<ex::set_value_t(),
+                                                            ex::set_error_t(std::exception_ptr),
+                                                            ex::set_stopped_t()>;
 
     bool from_scheduler_{false};
   };
 
-  struct my_scheduler {
+  struct my_scheduler
+  {
     [[nodiscard]]
-    auto schedule() const noexcept -> my_sender {
+    auto schedule() const noexcept -> my_sender
+    {
       return my_sender{true};
     }
 
-    auto operator==(const my_scheduler&) const noexcept -> bool = default;
+    auto operator==(my_scheduler const &) const noexcept -> bool = default;
   };
 
-  TEST_CASE("can call schedule on an appropriate type", "[cpo][cpo_schedule]") {
+  TEST_CASE("can call schedule on an appropriate type", "[cpo][cpo_schedule]")
+  {
     static_assert(std::invocable<ex::schedule_t, my_scheduler>, "invalid scheduler type");
     my_scheduler sched;
-    auto snd = ex::schedule(sched);
+    auto         snd = ex::schedule(sched);
     CHECK(snd.from_scheduler_);
   }
 
-  TEST_CASE("tag types can be deduced from ex::schedule", "[cpo][cpo_schedule]") {
-    static_assert(std::is_same_v<const ex::schedule_t, decltype(ex::schedule)>, "type mismatch");
+  TEST_CASE("tag types can be deduced from ex::schedule", "[cpo][cpo_schedule]")
+  {
+    static_assert(std::is_same_v<ex::schedule_t const, decltype(ex::schedule)>, "type mismatch");
   }
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/cpos/test_cpo_start.cpp b/test/stdexec/cpos/test_cpo_start.cpp
index bd7e6230b..76f9e0925 100644
--- a/test/stdexec/cpos/test_cpo_start.cpp
+++ b/test/stdexec/cpos/test_cpo_start.cpp
@@ -20,12 +20,15 @@
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  struct my_oper : immovable {
+  struct my_oper : immovable
+  {
     bool started_{false};
 
-    void start() noexcept {
+    void start() noexcept
+    {
       started_ = true;
     }
   };
@@ -33,59 +36,70 @@ namespace {
   STDEXEC_PRAGMA_PUSH()
   STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
-  struct op_rvalref : immovable {
+  struct op_rvalref : immovable
+  {
     bool* started_;
 
-    void start() && noexcept {
+    void start() && noexcept
+    {
       *started_ = true;
     }
   };
   STDEXEC_PRAGMA_POP()
 
-  struct op_ref : immovable {
+  struct op_ref : immovable
+  {
     bool* started_;
 
-    void start() & noexcept {
+    void start() & noexcept
+    {
       *started_ = true;
     }
   };
 
-  struct op_cref : immovable {
+  struct op_cref : immovable
+  {
     bool* started_;
 
-    void start() const noexcept {
+    void start() const noexcept
+    {
       *started_ = true;
     }
   };
 
-  TEST_CASE("can call start on an operation state", "[cpo][cpo_start]") {
+  TEST_CASE("can call start on an operation state", "[cpo][cpo_start]")
+  {
     my_oper op;
     ex::start(op);
     REQUIRE(op.started_);
   }
 
-  TEST_CASE("can call start on an oper with r-value ref type", "[cpo][cpo_start]") {
-    static_assert(
-      !std::invocable<ex::start_t, op_rvalref&&>, "should not be able to call start on op_rvalref");
+  TEST_CASE("can call start on an oper with r-value ref type", "[cpo][cpo_start]")
+  {
+    static_assert(!std::invocable<ex::start_t, op_rvalref&&>,
+                  "should not be able to call start on op_rvalref");
   }
 
-  TEST_CASE("can call start on an oper with ref type", "[cpo][cpo_start]") {
+  TEST_CASE("can call start on an oper with ref type", "[cpo][cpo_start]")
+  {
     static_assert(std::invocable<ex::start_t, op_ref&>, "cannot call start on op_ref");
-    bool started{false};
+    bool   started{false};
     op_ref op{{}, &started};
     ex::start(op);
     REQUIRE(started);
   }
 
-  TEST_CASE("can call start on an oper with const ref type", "[cpo][cpo_start]") {
-    static_assert(std::invocable<ex::start_t, const op_cref&>, "cannot call start on op_cref");
-    bool started{false};
-    const op_cref op{{}, &started};
+  TEST_CASE("can call start on an oper with const ref type", "[cpo][cpo_start]")
+  {
+    static_assert(std::invocable<ex::start_t, op_cref const &>, "cannot call start on op_cref");
+    bool          started{false};
+    op_cref const op{{}, &started};
     ex::start(op);
     REQUIRE(started);
   }
 
-  TEST_CASE("tag types can be deduced from ex::start", "[cpo][cpo_start]") {
-    static_assert(std::is_same_v<const ex::start_t, decltype(ex::start)>, "type mismatch");
+  TEST_CASE("tag types can be deduced from ex::start", "[cpo][cpo_start]")
+  {
+    static_assert(std::is_same_v<ex::start_t const, decltype(ex::start)>, "type mismatch");
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/cpos/test_cpo_upon_error.cpp b/test/stdexec/cpos/test_cpo_upon_error.cpp
index 16ef5a753..89e218c7f 100644
--- a/test/stdexec/cpos/test_cpo_upon_error.cpp
+++ b/test/stdexec/cpos/test_cpo_upon_error.cpp
@@ -18,27 +18,30 @@
 #include "test_common/receivers.hpp"
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("upon_error is customizable", "[cpo][cpo_upon_error]") {
-    const auto f = [](std::exception_ptr) {
+  TEST_CASE("upon_error is customizable", "[cpo][cpo_upon_error]")
+  {
+    auto const f = [](std::exception_ptr) {
     };
 
-    SECTION("by completion scheduler domain") {
+    SECTION("by completion scheduler domain")
+    {
       cpo_test_scheduler_t<ex::upon_error_t, ex::set_error_t>::sender_t snd{};
 
       {
-        constexpr scope_t scope =
-          decltype(ex::connect(snd | ex::upon_error(f), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(snd | ex::upon_error(f),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
 
       {
         void(ex::get_completion_scheduler<ex::set_error_t>(ex::get_env(snd)));
-        constexpr scope_t scope =
-          decltype(ex::connect(ex::upon_error(snd, f), empty_recv::recv0_ec{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(ex::upon_error(snd, f),
+                                                       empty_recv::recv0_ec{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/cpos/test_cpo_upon_stopped.cpp b/test/stdexec/cpos/test_cpo_upon_stopped.cpp
index 67a18669e..5efa9b299 100644
--- a/test/stdexec/cpos/test_cpo_upon_stopped.cpp
+++ b/test/stdexec/cpos/test_cpo_upon_stopped.cpp
@@ -18,27 +18,30 @@
 #include "test_common/receivers.hpp"
 #include <catch2/catch.hpp>
 
-namespace {
+namespace
+{
 
-  TEST_CASE("upon_stopped is customizable", "[cpo][cpo_upon_stopped]") {
-    const auto f = []() {
+  TEST_CASE("upon_stopped is customizable", "[cpo][cpo_upon_stopped]")
+  {
+    auto const f = []() {
     };
 
-    SECTION("by completion scheduler domain") {
+    SECTION("by completion scheduler domain")
+    {
       cpo_test_scheduler_t<ex::upon_stopped_t, ex::set_stopped_t>::sender_t snd{};
 
       {
-        constexpr scope_t scope =
-          decltype(ex::connect(snd | ex::upon_stopped(f), empty_recv::recv0{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(snd | ex::upon_stopped(f),
+                                                       empty_recv::recv0{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
 
       {
         void(ex::get_completion_scheduler<ex::set_stopped_t>(ex::get_env(snd)));
-        constexpr scope_t scope =
-          decltype(ex::connect(ex::upon_stopped(snd, f), empty_recv::recv0{}))::sender_t::scope;
+        constexpr scope_t scope = decltype(ex::connect(ex::upon_stopped(snd, f),
+                                                       empty_recv::recv0{}))::sender_t::scope;
         STATIC_REQUIRE(scope == scope_t::scheduler);
       }
     }
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/detail/test_any.cpp b/test/stdexec/detail/test_any.cpp
index 6be25eff0..2cb05dd31 100644
--- a/test/stdexec/detail/test_any.cpp
+++ b/test/stdexec/detail/test_any.cpp
@@ -18,75 +18,91 @@
 
 #include <cstdio>
 
-#include <catch2/catch.hpp> // IWYU pragma: keep
+#include <catch2/catch.hpp>  // IWYU pragma: keep
 
 namespace any = STDEXEC::__any;
 
 template <class Base>
-struct ifoo : any::interface<ifoo, Base> {
+struct ifoo : any::interface<ifoo, Base>
+{
   using ifoo::interface::interface;
 
-  constexpr virtual void foo() {
+  constexpr virtual void foo()
+  {
     any::__value(*this).foo();
   }
 
-  constexpr virtual void cfoo() const {
+  constexpr virtual void cfoo() const
+  {
     any::__value(*this).cfoo();
   }
 };
 
 template <class Base>
-struct ibar : any::interface<ibar, Base, any::__extends<ifoo, any::__icopyable>> {
+struct ibar : any::interface<ibar, Base, any::__extends<ifoo, any::__icopyable>>
+{
   using ibar::interface::interface;
 
-  constexpr virtual void bar() {
+  constexpr virtual void bar()
+  {
     any::__value(*this).bar();
   }
 };
 
 template <class Base>
-struct ibaz : any::interface<ibaz, Base, any::__extends<ibar>, 5 * sizeof(void *)> {
+struct ibaz : any::interface<ibaz, Base, any::__extends<ibar>, 5 * sizeof(void *)>
+{
   using ibaz::interface::interface;
 
   constexpr ~ibaz() = default;
 
-  constexpr virtual void baz() {
+  constexpr virtual void baz()
+  {
     any::__value(*this).baz();
   }
 };
 
 using Small = char;
-using Big = char[sizeof(any::__any<ibaz>) + 1];
+using Big   = char[sizeof(any::__any<ibaz>) + 1];
 
 template <class State>
-struct foobar {
-  constexpr void foo() {
-    STDEXEC_IF_NOT_CONSTEVAL {
+struct foobar
+{
+  constexpr void foo()
+  {
+    STDEXEC_IF_NOT_CONSTEVAL
+    {
       std::printf("foo override, __value = %d\n", __value);
     }
   }
 
-  constexpr void cfoo() const {
-    STDEXEC_IF_NOT_CONSTEVAL {
+  constexpr void cfoo() const
+  {
+    STDEXEC_IF_NOT_CONSTEVAL
+    {
       std::printf("cfoo override, __value = %d\n", __value);
     }
   }
 
-  constexpr void bar() {
-    STDEXEC_IF_NOT_CONSTEVAL {
+  constexpr void bar()
+  {
+    STDEXEC_IF_NOT_CONSTEVAL
+    {
       std::printf("bar override, __value = %d\n", __value);
     }
   }
 
-  constexpr void baz() {
-    STDEXEC_IF_NOT_CONSTEVAL {
+  constexpr void baz()
+  {
+    STDEXEC_IF_NOT_CONSTEVAL
+    {
       std::printf("baz override, __value = %d\n", __value);
     }
   }
 
   bool operator==(foobar const &other) const noexcept = default;
 
-  int __value = 42;
+  int   __value = 42;
   State state;
 };
 
@@ -98,31 +114,35 @@ static_assert(any::__extension_of<any::__iabstract<ibar>, any::__icopyable>);
 
 // Test the Diamond of Death inheritance problem:
 template <class Base>
-struct IFoo : any::interface<IFoo, Base, any::__extends<any::__icopyable>> {
+struct IFoo : any::interface<IFoo, Base, any::__extends<any::__icopyable>>
+{
   using IFoo::interface::interface;
 
-  constexpr virtual void foo() {
+  constexpr virtual void foo()
+  {
     any::__value(*this).foo();
   }
 };
 
 template <class Base>
-struct IBar : any::interface<IBar, Base, any::__extends<any::__icopyable>> {
+struct IBar : any::interface<IBar, Base, any::__extends<any::__icopyable>>
+{
   using IBar::interface::interface;
 
-  constexpr virtual void bar() {
+  constexpr virtual void bar()
+  {
     any::__value(*this).bar();
   }
 };
 
 template <class Base>
-struct IBaz
-  : any::interface<IBaz, Base, any::__extends<IFoo, IBar>> // inherits twice
-                                                           // from __icopyable
+struct IBaz : any::interface<IBaz, Base, any::__extends<IFoo, IBar>>  // inherits twice
+                                                                      // from __icopyable
 {
   using IBaz::interface::interface;
 
-  constexpr virtual void baz() {
+  constexpr virtual void baz()
+  {
     any::__value(*this).baz();
   }
 };
@@ -131,7 +151,8 @@ static_assert(std::derived_from<any::__iabstract<IBaz>, any::__iabstract<IFoo>>)
 static_assert(std::derived_from<any::__iabstract<IBaz>, any::__iabstract<any::__icopyable>>);
 
 template <class T>
-void test_deadly_diamond_of_death() {
+void test_deadly_diamond_of_death()
+{
   any::__any<IBaz> m(foobar<T>{});
 
   m.foo();
@@ -143,11 +164,12 @@ static_assert(any::__iabstract<ifoo>::__buffer_size < any::__iabstract<ibaz>::__
 
 // test constant evaluation works
 template <class T>
-consteval void test_consteval() {
+consteval void test_consteval()
+{
   any::__any<ibaz> m(foobar<T>{});
   [[maybe_unused]]
   auto x = any::__any_static_cast<foobar<T>>(m);
-  x = any::__any_cast<foobar<T>>(m);
+  x      = any::__any_cast<foobar<T>>(m);
   m.foo();
   [[maybe_unused]]
   auto n = m;
@@ -163,9 +185,10 @@ consteval void test_consteval() {
   auto y = any::__any_cast<foobar<T>>(pifoo);
 }
 
-TEMPLATE_TEST_CASE("basic usage of any::__any", "[detail][any]", foobar<Small>, foobar<Big>) {
+TEMPLATE_TEST_CASE("basic usage of any::__any", "[detail][any]", foobar<Small>, foobar<Big>)
+{
 #if STDEXEC_CLANG() || (STDEXEC_GCC() && STDEXEC_GCC_VERSION >= 14'03)
-  test_consteval<TestType>(); // NOLINT(invalid_consteval_call)
+  test_consteval<TestType>();  // NOLINT(invalid_consteval_call)
 #endif
 
   any::__any<ibaz> m(foobar<TestType>{});
@@ -188,7 +211,7 @@ TEMPLATE_TEST_CASE("basic usage of any::__any", "[detail][any]", foobar<Small>,
   auto const ptr2 = any::__addressof(m);
   ptr2->foo();
   any::__any_ptr<ifoo> pifoo = ptr2;
-  m = *ptr; // assignment from type-erased references is supported
+  m                          = *ptr;  // assignment from type-erased references is supported
 
   any::__any<any::__isemiregular> a = 42;
   any::__any<any::__isemiregular> b = 42;
@@ -227,7 +250,7 @@ TEMPLATE_TEST_CASE("basic usage of any::__any", "[detail][any]", foobar<Small>,
   int *r = any::__any_cast<int>(std::move(y));
   REQUIRE(r == &any::__any_cast<int>(c));
 
-  z = y; // assign non-const ptr to const ptr
+  z = y;  // assign non-const ptr to const ptr
   z = &*y;
 
   REQUIRE(y == z);
diff --git a/test/stdexec/detail/test_completion_signatures.cpp b/test/stdexec/detail/test_completion_signatures.cpp
index bc7b397be..7c74ac713 100644
--- a/test/stdexec/detail/test_completion_signatures.cpp
+++ b/test/stdexec/detail/test_completion_signatures.cpp
@@ -21,7 +21,8 @@ namespace ex = STDEXEC;
 
 using namespace std;
 
-namespace {
+namespace
+{
 
   template <class... Vs>
   using set_value_sig = ex::set_value_t(Vs...);
@@ -29,7 +30,8 @@ namespace {
   template <class E>
   using set_error_sig = ex::set_error_t(E);
 
-  TEST_CASE("test the internal __completion_signature concept", "[detail][completion_signatures]") {
+  TEST_CASE("test the internal __completion_signature concept", "[detail][completion_signatures]")
+  {
     static_assert(ex::__completion_signature<ex::set_value_t()>);
     static_assert(ex::__completion_signature<ex::set_value_t(int)>);
     static_assert(ex::__completion_signature<ex::set_value_t(int, int)>);
@@ -49,9 +51,10 @@ namespace {
     static_assert(!ex::__completion_signature<ex::set_stopped_t() noexcept>);
   }
 
-  TEST_CASE(
-    "set_value_sig can be used to transform value types to corresponding completion signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("set_value_sig can be used to transform value types to corresponding completion "
+            "signatures",
+            "[detail][completion_signatures]")
+  {
     using set_value_f = ex::__q<set_value_sig>;
 
     using tr = ex::__mtransform<set_value_f, ex::__q<ex::__mlist>>;
@@ -62,45 +65,44 @@ namespace {
     static_assert(is_same_v<res, expected>);
   }
 
-  TEST_CASE(
-    "set_error_sig can be used to transform error types to corresponding completion signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("set_error_sig can be used to transform error types to corresponding completion "
+            "signatures",
+            "[detail][completion_signatures]")
+  {
     using set_error_f = ex::__q<set_error_sig>;
 
     using tr = ex::__mtransform<set_error_f, ex::__q<ex::__mlist>>;
 
-    using res = ex::__minvoke<tr, exception_ptr, error_code, string>;
-    using expected = ex::__mlist<
-      ex::set_error_t(exception_ptr),
-      ex::set_error_t(error_code),
-      ex::set_error_t(string)
-    >;
+    using res      = ex::__minvoke<tr, exception_ptr, error_code, string>;
+    using expected = ex::__mlist<ex::set_error_t(exception_ptr),
+                                 ex::set_error_t(error_code),
+                                 ex::set_error_t(string)>;
     static_assert(is_same_v<res, expected>);
   }
 
-  TEST_CASE(
-    "set_error_sig can be used to transform exception_ptr",
-    "[detail][completion_signatures]") {
+  TEST_CASE("set_error_sig can be used to transform exception_ptr",
+            "[detail][completion_signatures]")
+  {
     using set_error_f = ex::__q<set_error_sig>;
 
     using tr = ex::__mtransform<set_error_f, ex::__q<ex::__mlist>>;
 
-    using res = ex::__minvoke<tr, exception_ptr>;
+    using res      = ex::__minvoke<tr, exception_ptr>;
     using expected = ex::__mlist<ex::set_error_t(exception_ptr)>;
     static_assert(is_same_v<res, expected>);
   }
 
-  TEST_CASE(
-    "__error_types_of_t gets the error types from sender",
-    "[detail][completion_signatures]") {
-    using snd_eptr_t = decltype(ex::just_error(exception_ptr{}));
-    using snd_ec_t = decltype(ex::just_error(error_code{}));
-    using snd_str_t = decltype(ex::just_error(std::string{}));
+  TEST_CASE("__error_types_of_t gets the error types from sender",
+            "[detail][completion_signatures]")
+  {
+    using snd_eptr_t    = decltype(ex::just_error(exception_ptr{}));
+    using snd_ec_t      = decltype(ex::just_error(error_code{}));
+    using snd_str_t     = decltype(ex::just_error(std::string{}));
     using snd_tr_just_t = decltype(ex::just() | ex::continues_on(error_scheduler{}));
 
-    using err_types_eptr = ex::__error_types_of_t<snd_eptr_t>;
-    using err_types_ec = ex::__error_types_of_t<snd_ec_t>;
-    using err_types_str = ex::__error_types_of_t<snd_str_t>;
+    using err_types_eptr    = ex::__error_types_of_t<snd_eptr_t>;
+    using err_types_ec      = ex::__error_types_of_t<snd_ec_t>;
+    using err_types_str     = ex::__error_types_of_t<snd_str_t>;
     using err_types_tr_just = ex::__error_types_of_t<snd_tr_just_t>;
 
     static_assert(is_same_v<err_types_eptr, variant<exception_ptr>>);
@@ -109,19 +111,18 @@ namespace {
     static_assert(is_same_v<err_types_tr_just, variant<exception_ptr>>);
   }
 
-  TEST_CASE(
-    "__error_types_of_t can also transform error types",
-    "[detail][completion_signatures]") {
+  TEST_CASE("__error_types_of_t can also transform error types", "[detail][completion_signatures]")
+  {
     using snd_eptr_t = decltype(ex::just_error(exception_ptr{}));
-    using snd_ec_t = decltype(ex::just_error(error_code{}));
-    using snd_str_t = decltype(ex::just_error(std::string{}));
+    using snd_ec_t   = decltype(ex::just_error(error_code{}));
+    using snd_str_t  = decltype(ex::just_error(std::string{}));
 
     using set_error_f = ex::__q<set_error_sig>;
-    using tr = ex::__mtransform<set_error_f>;
+    using tr          = ex::__mtransform<set_error_f>;
 
     using sig_eptr = ex::__error_types_of_t<snd_eptr_t, ex::env<>, tr>;
-    using sig_ec = ex::__error_types_of_t<snd_ec_t, ex::env<>, tr>;
-    using sig_str = ex::__error_types_of_t<snd_str_t, ex::env<>, tr>;
+    using sig_ec   = ex::__error_types_of_t<snd_ec_t, ex::env<>, tr>;
+    using sig_str  = ex::__error_types_of_t<snd_str_t, ex::env<>, tr>;
 
     static_assert(is_same_v<sig_eptr, ex::__mlist<ex::set_error_t(exception_ptr)>>);
     static_assert(is_same_v<sig_ec, ex::__mlist<ex::set_error_t(error_code)>>);
@@ -129,7 +130,8 @@ namespace {
   }
 
   template <class CS, class... Expected>
-  void expect_val_types() {
+  void expect_val_types()
+  {
     using expected_t = ex::__mmake_set<Expected...>;
     using actual_t =
       ex::__gather_completions_t<ex::set_value_t, CS, ex::__q<ex::__mlist>, ex::__q<ex::__mset>>;
@@ -137,27 +139,29 @@ namespace {
   }
 
   template <class CS, class... Expected>
-  void expect_err_types() {
+  void expect_err_types()
+  {
     using expected_t = ex::__mmake_set<Expected...>;
     using actual_t =
       ex::__gather_completions_t<ex::set_error_t, CS, ex::__q<ex::__midentity>, ex::__q<ex::__mset>>;
     static_assert(ex::__mset_eq<actual_t, expected_t>);
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of can replicate the completion signatures of input senders",
-    "[detail][completion_signatures]") {
-    using snd_int_t = decltype(ex::just(0));
+  TEST_CASE("transform_completion_signatures_of can replicate the completion signatures of input "
+            "senders",
+            "[detail][completion_signatures]")
+  {
+    using snd_int_t         = decltype(ex::just(0));
     using snd_double_char_t = decltype(ex::just(3.14, 'p'));
-    using snd_eptr_t = decltype(ex::just_error(exception_ptr{}));
-    using snd_ec_t = decltype(ex::just_error(error_code{}));
-    using snd_stopped_t = decltype(ex::just_stopped());
+    using snd_eptr_t        = decltype(ex::just_error(exception_ptr{}));
+    using snd_ec_t          = decltype(ex::just_error(error_code{}));
+    using snd_stopped_t     = decltype(ex::just_stopped());
 
-    using cs_int = ex::transform_completion_signatures_of<snd_int_t>;
+    using cs_int         = ex::transform_completion_signatures_of<snd_int_t>;
     using cs_double_char = ex::transform_completion_signatures_of<snd_double_char_t>;
-    using cs_eptr = ex::transform_completion_signatures_of<snd_eptr_t>;
-    using cs_ec = ex::transform_completion_signatures_of<snd_ec_t>;
-    using cs_stopped = ex::transform_completion_signatures_of<snd_stopped_t>;
+    using cs_eptr        = ex::transform_completion_signatures_of<snd_eptr_t>;
+    using cs_ec          = ex::transform_completion_signatures_of<snd_ec_t>;
+    using cs_stopped     = ex::transform_completion_signatures_of<snd_stopped_t>;
 
     expect_val_types<cs_int, ex::__mlist<int>>();
     expect_val_types<cs_double_char, ex::__mlist<double, char>>();
@@ -172,22 +176,23 @@ namespace {
     expect_err_types<cs_stopped>();
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of with ex::env<> can replicate the completion signatures of "
-    "input "
-    "senders",
-    "[detail][completion_signatures]") {
-    using snd_int_t = decltype(ex::just(0));
+  TEST_CASE("transform_completion_signatures_of with ex::env<> can replicate the completion "
+            "signatures of "
+            "input "
+            "senders",
+            "[detail][completion_signatures]")
+  {
+    using snd_int_t         = decltype(ex::just(0));
     using snd_double_char_t = decltype(ex::just(3.14, 'p'));
-    using snd_eptr_t = decltype(ex::just_error(exception_ptr{}));
-    using snd_ec_t = decltype(ex::just_error(error_code{}));
-    using snd_stopped_t = decltype(ex::just_stopped());
+    using snd_eptr_t        = decltype(ex::just_error(exception_ptr{}));
+    using snd_ec_t          = decltype(ex::just_error(error_code{}));
+    using snd_stopped_t     = decltype(ex::just_stopped());
 
-    using cs_int = ex::transform_completion_signatures_of<snd_int_t, ex::env<>>;
+    using cs_int         = ex::transform_completion_signatures_of<snd_int_t, ex::env<>>;
     using cs_double_char = ex::transform_completion_signatures_of<snd_double_char_t, ex::env<>>;
-    using cs_eptr = ex::transform_completion_signatures_of<snd_eptr_t, ex::env<>>;
-    using cs_ec = ex::transform_completion_signatures_of<snd_ec_t, ex::env<>>;
-    using cs_stopped = ex::transform_completion_signatures_of<snd_stopped_t, ex::env<>>;
+    using cs_eptr        = ex::transform_completion_signatures_of<snd_eptr_t, ex::env<>>;
+    using cs_ec          = ex::transform_completion_signatures_of<snd_ec_t, ex::env<>>;
+    using cs_stopped     = ex::transform_completion_signatures_of<snd_stopped_t, ex::env<>>;
 
     expect_val_types<cs_int, ex::__mlist<int>>();
     expect_val_types<cs_double_char, ex::__mlist<double, char>>();
@@ -202,43 +207,41 @@ namespace {
     expect_err_types<cs_stopped>();
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of can add other error signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("transform_completion_signatures_of can add other error signatures",
+            "[detail][completion_signatures]")
+  {
     using snd_double_t = decltype(ex::just_error(std::exception_ptr{}));
-    using cs_with_ec = ex::transform_completion_signatures_of<
-      snd_double_t,
-      ex::env<>,
-      ex::completion_signatures<ex::set_error_t(error_code)>
-    >;
+    using cs_with_ec   = ex::transform_completion_signatures_of<
+        snd_double_t,
+        ex::env<>,
+        ex::completion_signatures<ex::set_error_t(error_code)>>;
 
     expect_val_types<cs_with_ec>();
     expect_err_types<cs_with_ec, error_code, exception_ptr>();
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of can add other error signatures, but will dedup them",
-    "[detail][completion_signatures]") {
+  TEST_CASE("transform_completion_signatures_of can add other error signatures, but will dedup "
+            "them",
+            "[detail][completion_signatures]")
+  {
     using snd_double_t = decltype(ex::just(3.14));
-    using cs_with_ec = ex::transform_completion_signatures_of<
-      snd_double_t,
-      ex::env<>,
-      ex::completion_signatures<ex::set_error_t(exception_ptr)>
-    >;
+    using cs_with_ec   = ex::transform_completion_signatures_of<
+        snd_double_t,
+        ex::env<>,
+        ex::completion_signatures<ex::set_error_t(exception_ptr)>>;
 
     // exception_ptr appears only once
     expect_err_types<cs_with_ec, exception_ptr>();
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of can add other value signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("transform_completion_signatures_of can add other value signatures",
+            "[detail][completion_signatures]")
+  {
     using snd_double_t = decltype(ex::just(3.14));
-    using cs = ex::transform_completion_signatures_of<
-      snd_double_t,
-      ex::env<>,
-      ex::completion_signatures<ex::set_value_t(int), ex::set_value_t(double)>
-    >;
+    using cs           = ex::transform_completion_signatures_of<
+                snd_double_t,
+                ex::env<>,
+                ex::completion_signatures<ex::set_value_t(int), ex::set_value_t(double)>>;
 
     // will add int, double will appear only once
     expect_val_types<cs, ex::__mlist<int>, ex::__mlist<double>>();
@@ -250,56 +253,55 @@ namespace {
   template <class Err>
   using optional_set_error_sig = ex::completion_signatures<ex::set_error_t(optional<Err>)>;
 
-  TEST_CASE(
-    "transform_completion_signatures_of can transform value types signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("transform_completion_signatures_of can transform value types signatures",
+            "[detail][completion_signatures]")
+  {
     using snd_double_t = decltype(ex::just(3.14));
-    using cs = ex::transform_completion_signatures_of<
-      snd_double_t,
-      ex::env<>,
-      ex::completion_signatures<ex::set_value_t(int), ex::set_value_t(double)>,
-      add_int_set_value_sig
-    >;
+    using cs           = ex::transform_completion_signatures_of<
+                snd_double_t,
+                ex::env<>,
+                ex::completion_signatures<ex::set_value_t(int), ex::set_value_t(double)>,
+                add_int_set_value_sig>;
 
     // will transform the original "double" into <string, double>
     // then will add the other "int" and "double"
     expect_val_types<cs, ex::__mlist<int>, ex::__mlist<double>, ex::__mlist<string, double>>();
   }
 
-  TEST_CASE(
-    "transform_completion_signatures_of can transform error types signatures",
-    "[detail][completion_signatures]") {
+  TEST_CASE("transform_completion_signatures_of can transform error types signatures",
+            "[detail][completion_signatures]")
+  {
     using snd_eptr_t = decltype(ex::just_error(std::exception_ptr{}));
-    using cs = ex::transform_completion_signatures_of<
-      snd_eptr_t,
-      ex::env<>,
-      ex::completion_signatures<ex::set_error_t(error_code)>,
-      ex::__cmplsigs::__default_set_value,
-      optional_set_error_sig
-    >;
+    using cs =
+      ex::transform_completion_signatures_of<snd_eptr_t,
+                                             ex::env<>,
+                                             ex::completion_signatures<ex::set_error_t(error_code)>,
+                                             ex::__cmplsigs::__default_set_value,
+                                             optional_set_error_sig>;
 
     // will transform the original "exception_ptr" into optional<exception_ptr>
     // then will add the other "error_code" as specified in the additional signatures
     expect_err_types<cs, error_code, optional<exception_ptr>>();
   }
 
-  TEST_CASE("error_types_of_t can be used to get error types", "[detail][completion_signatures]") {
-    using snd_t = decltype(ex::when_all(
-      ex::just_error(std::error_code{}), ex::just_error(std::exception_ptr{})));
-    using actual_t = ex::error_types_of_t<snd_t, ex::env<>, ex::__mset>;
+  TEST_CASE("error_types_of_t can be used to get error types", "[detail][completion_signatures]")
+  {
+    using snd_t      = decltype(ex::when_all(ex::just_error(std::error_code{}),
+                                        ex::just_error(std::exception_ptr{})));
+    using actual_t   = ex::error_types_of_t<snd_t, ex::env<>, ex::__mset>;
     using expected_t = ex::__mset<std::error_code, std::exception_ptr>;
     static_assert(ex::__mset_eq<actual_t, expected_t>);
   }
 
-  TEST_CASE(
-    "regression: error_types_of_t can be used to transform error types",
-    "[detail][completion_signatures]") {
+  TEST_CASE("regression: error_types_of_t can be used to transform error types",
+            "[detail][completion_signatures]")
+  {
     using tr = ex::__mtransform<ex::__q<optional>, ex::__q<ex::__mset>>;
 
-    using snd_t = decltype(ex::when_all(
-      ex::just_error(std::error_code{}), ex::just_error(std::exception_ptr{})));
-    using actual_t = ex::error_types_of_t<snd_t, ex::env<>, tr::__f>;
+    using snd_t      = decltype(ex::when_all(ex::just_error(std::error_code{}),
+                                        ex::just_error(std::exception_ptr{})));
+    using actual_t   = ex::error_types_of_t<snd_t, ex::env<>, tr::__f>;
     using expected_t = ex::__mset<optional<std::error_code>, optional<std::exception_ptr>>;
     static_assert(ex::__mset_eq<actual_t, expected_t>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/detail/test_utility.cpp b/test/stdexec/detail/test_utility.cpp
index 4cb983872..da32785e0 100644
--- a/test/stdexec/detail/test_utility.cpp
+++ b/test/stdexec/detail/test_utility.cpp
@@ -22,20 +22,20 @@
 using namespace std;
 using namespace STDEXEC;
 
-namespace {
+namespace
+{
 
-  TEST_CASE(
-    "transform identity will return the given types (wrapped in __mlist)",
-    "[detail][transform]") {
-    using tr = __mtransform<__q<__midentity>>;
+  TEST_CASE("transform identity will return the given types (wrapped in __mlist)",
+            "[detail][transform]")
+  {
+    using tr  = __mtransform<__q<__midentity>>;
     using res = __minvoke<tr, int, char>;
     static_assert(is_same_v<res, __mlist<int, char>>);
   }
 
-  TEST_CASE(
-    "transform can avoid the __mlist wrapping with __q<__midentity>",
-    "[detail][transform]") {
-    using tr = __mtransform<__q<__midentity>, __q<__midentity>>;
+  TEST_CASE("transform can avoid the __mlist wrapping with __q<__midentity>", "[detail][transform]")
+  {
+    using tr  = __mtransform<__q<__midentity>, __q<__midentity>>;
     using res = __minvoke<tr, int>;
     static_assert(is_same_v<res, int>);
   }
@@ -43,17 +43,18 @@ namespace {
   template <typename T>
   using as_optional = std::optional<T>;
 
-  TEST_CASE("transform can wrap input types", "[detail][transform]") {
-    using tr = __mtransform<__q<as_optional>>;
+  TEST_CASE("transform can wrap input types", "[detail][transform]")
+  {
+    using tr  = __mtransform<__q<as_optional>>;
     using res = __minvoke<tr, int, char>;
     static_assert(is_same_v<res, __mlist<optional<int>, optional<char>>>);
   }
 
-  TEST_CASE(
-    "transform continuation can be used to wrap the result in another template",
-    "[detail][transform]") {
-    using tr = __mtransform<__q<as_optional>, __q<tuple>>;
+  TEST_CASE("transform continuation can be used to wrap the result in another template",
+            "[detail][transform]")
+  {
+    using tr  = __mtransform<__q<as_optional>, __q<tuple>>;
     using res = __minvoke<tr, int, char>;
     static_assert(is_same_v<res, tuple<optional<int>, optional<char>>>);
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/queries/test_env.cpp b/test/stdexec/queries/test_env.cpp
index 038a29ac3..b5926f48a 100644
--- a/test/stdexec/queries/test_env.cpp
+++ b/test/stdexec/queries/test_env.cpp
@@ -19,49 +19,58 @@
 #include <catch2/catch.hpp>
 #include <stdexec/execution.hpp>
 
-namespace {
+namespace
+{
 
   template <typename T>
-  concept can_get_domain = requires(const T& t) { t.query(::STDEXEC::get_domain); };
+  concept can_get_domain = requires(T const & t) { t.query(::STDEXEC::get_domain); };
 
-  namespace zero {
+  namespace zero
+  {
     using env = ::STDEXEC::env<>;
     static_assert(std::is_same_v<::STDEXEC::never_stop_token, ::STDEXEC::stop_token_of_t<env>>);
     static_assert(!can_get_domain<env>);
-  } // namespace zero
+  }  // namespace zero
 
-  namespace one {
+  namespace one
+  {
     using env = ::STDEXEC::env<::STDEXEC::env<>>;
     static_assert(std::is_same_v<::STDEXEC::never_stop_token, ::STDEXEC::stop_token_of_t<env>>);
     static_assert(!can_get_domain<env>);
-  } // namespace one
+  }  // namespace one
 
-  namespace two {
+  namespace two
+  {
     using env = ::STDEXEC::env<::STDEXEC::env<>, ::STDEXEC::env<>>;
     static_assert(std::is_same_v<::STDEXEC::never_stop_token, ::STDEXEC::stop_token_of_t<env>>);
     static_assert(!can_get_domain<env>);
-  } // namespace two
+  }  // namespace two
 
-  namespace three {
+  namespace three
+  {
     using env = ::STDEXEC::env<::STDEXEC::env<>, ::STDEXEC::env<>, ::STDEXEC::env<>>;
     static_assert(std::is_same_v<::STDEXEC::never_stop_token, ::STDEXEC::stop_token_of_t<env>>);
     static_assert(!can_get_domain<env>);
-  } // namespace three
+  }  // namespace three
 
   // https://github.com/NVIDIA/stdexec/issues/1840
   constexpr struct FwdFoo
     : STDEXEC::__query<FwdFoo>
-    , STDEXEC::forwarding_query_t {
+    , STDEXEC::forwarding_query_t
+  {
     using STDEXEC::__query<FwdFoo>::operator();
   } fwd_foo{};
 
-  constexpr struct Foo : STDEXEC::__query<Foo> {
+  constexpr struct Foo : STDEXEC::__query<Foo>
+  {
   } foo{};
 
-  constexpr struct Bar : STDEXEC::__query<Bar> {
+  constexpr struct Bar : STDEXEC::__query<Bar>
+  {
   } bar{};
 
-  constexpr bool test() {
+  constexpr bool test()
+  {
     auto env = STDEXEC::env{
       STDEXEC::env{STDEXEC::prop{fwd_foo, 42.}, STDEXEC::prop{foo, 'F'}},
       STDEXEC::prop{                        bar,                   31415}
@@ -73,10 +82,9 @@ namespace {
   static_assert(test());
 
   struct EnvOfThree
-    : STDEXEC::env<
-        STDEXEC::env<STDEXEC::prop<FwdFoo, int>, STDEXEC::prop<Foo, int>>,
-        STDEXEC::prop<Bar, int>
-      > { };
+    : STDEXEC::env<STDEXEC::env<STDEXEC::prop<FwdFoo, int>, STDEXEC::prop<Foo, int>>,
+                   STDEXEC::prop<Bar, int>>
+  {};
 
   static_assert(STDEXEC::__queryable_with<EnvOfThree, Foo>);
-} // namespace
+}  // namespace
diff --git a/test/stdexec/queries/test_forwarding_queries.cpp b/test/stdexec/queries/test_forwarding_queries.cpp
index 0a8ed0bac..10eaf7538 100644
--- a/test/stdexec/queries/test_forwarding_queries.cpp
+++ b/test/stdexec/queries/test_forwarding_queries.cpp
@@ -17,37 +17,42 @@
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity_with_custom_message)
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // 'foo': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // 'foo': was declared deprecated
 
 namespace ex = STDEXEC;
 
-namespace {
+namespace
+{
 
-  struct my_forwarding_query_t {
+  struct my_forwarding_query_t
+  {
     [[nodiscard]]
-    constexpr auto query(ex::forwarding_query_t) const noexcept -> bool {
+    constexpr auto query(ex::forwarding_query_t) const noexcept -> bool
+    {
       return true;
     }
   };
 
   inline constexpr my_forwarding_query_t my_forwarding_query{};
 
-  struct my_derived_forwarding_query_t : ex::forwarding_query_t { };
+  struct my_derived_forwarding_query_t : ex::forwarding_query_t
+  {};
 
   inline constexpr my_derived_forwarding_query_t my_derived_forwarding_query{};
 
-  struct my_non_forwarding_query_t { };
+  struct my_non_forwarding_query_t
+  {};
 
   inline constexpr my_non_forwarding_query_t my_non_forwarding_query{};
 
-  TEST_CASE("exec.queries are forwarding queries", "[exec.queries][forwarding_queries]") {
+  TEST_CASE("exec.queries are forwarding queries", "[exec.queries][forwarding_queries]")
+  {
     static_assert(ex::forwarding_query(ex::get_allocator));
     static_assert(ex::forwarding_query(ex::get_stop_token));
     static_assert(ex::forwarding_query(ex::get_scheduler));
     static_assert(ex::forwarding_query(ex::get_delegation_scheduler));
-    static_assert(
-      std::is_same_v<ex::get_delegatee_scheduler_t, ex::get_delegation_scheduler_t>,
-      "Deprecated type is the same type.");
+    static_assert(std::is_same_v<ex::get_delegatee_scheduler_t, ex::get_delegation_scheduler_t>,
+                  "Deprecated type is the same type.");
     static_assert(&ex::get_delegatee_scheduler == &ex::get_delegation_scheduler);
     static_assert(ex::forwarding_query(ex::get_completion_scheduler<ex::set_value_t>));
     static_assert(ex::forwarding_query(ex::get_completion_scheduler<ex::set_error_t>));
@@ -57,4 +62,4 @@ namespace {
     static_assert(ex::forwarding_query(my_derived_forwarding_query));
     static_assert(!ex::forwarding_query(my_non_forwarding_query));
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/queries/test_get_forward_progress_guarantee.cpp b/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
index 318d661a5..8fa3d3d87 100644
--- a/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
+++ b/test/stdexec/queries/test_get_forward_progress_guarantee.cpp
@@ -23,111 +23,126 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
 namespace ex = STDEXEC;
 
-namespace {
-  struct uncustomized_scheduler {
-    struct operation_state {
-      void start() & noexcept {
-      }
+namespace
+{
+  struct uncustomized_scheduler
+  {
+    struct operation_state
+    {
+      void start() & noexcept {}
     };
 
-    struct sender {
+    struct sender
+    {
       using sender_concept = STDEXEC::sender_t;
       using completion_signatures =
         ex::completion_signatures<ex::set_value_t(), ex::set_error_t(std::exception_ptr)>;
 
       template <typename R>
-      auto connect(R&&) const -> operation_state {
+      auto connect(R &&) const -> operation_state
+      {
         return {};
       }
 
-      struct env {
+      struct env
+      {
         template <STDEXEC::__completion_tag Tag>
-        auto query(ex::get_completion_scheduler_t<Tag>) const noexcept -> uncustomized_scheduler {
+        auto query(ex::get_completion_scheduler_t<Tag>) const noexcept -> uncustomized_scheduler
+        {
           return {};
         }
       };
 
       [[nodiscard]]
-      auto get_env() const noexcept -> env {
+      auto get_env() const noexcept -> env
+      {
         return {};
       }
     };
 
     [[nodiscard]]
-    auto schedule() const noexcept -> sender {
+    auto schedule() const noexcept -> sender
+    {
       return {};
     }
 
-    auto operator==(const uncustomized_scheduler&) const noexcept -> bool = default;
+    auto operator==(uncustomized_scheduler const &) const noexcept -> bool = default;
   };
 
   template <ex::forward_progress_guarantee fpg>
-  struct customized_scheduler {
-    struct operation_state {
-      void start() & noexcept {
-      }
+  struct customized_scheduler
+  {
+    struct operation_state
+    {
+      void start() & noexcept {}
     };
 
-    struct sender {
+    struct sender
+    {
       using sender_concept = STDEXEC::sender_t;
       using completion_signatures =
         ex::completion_signatures<ex::set_value_t(), ex::set_error_t(std::exception_ptr)>;
 
       template <typename R>
-      auto connect(R&&) const -> operation_state {
+      auto connect(R &&) const -> operation_state
+      {
         return {};
       }
 
-      struct env {
+      struct env
+      {
         template <STDEXEC::__completion_tag Tag>
-        auto query(ex::get_completion_scheduler_t<Tag>) const noexcept -> customized_scheduler {
+        auto query(ex::get_completion_scheduler_t<Tag>) const noexcept -> customized_scheduler
+        {
           return {};
         }
       };
 
-      auto get_env() const noexcept -> env {
+      auto get_env() const noexcept -> env
+      {
         return {};
       }
     };
 
     [[nodiscard]]
-    auto schedule() const -> sender {
+    auto schedule() const -> sender
+    {
       return {};
     }
 
-    friend auto operator==(customized_scheduler, customized_scheduler) noexcept -> bool {
+    friend auto operator==(customized_scheduler, customized_scheduler) noexcept -> bool
+    {
       return true;
     }
 
-    friend auto operator!=(customized_scheduler, customized_scheduler) noexcept -> bool {
+    friend auto operator!=(customized_scheduler, customized_scheduler) noexcept -> bool
+    {
       return false;
     }
 
     [[nodiscard]]
     constexpr auto
-      query(ex::get_forward_progress_guarantee_t) const noexcept -> ex::forward_progress_guarantee {
+    query(ex::get_forward_progress_guarantee_t) const noexcept -> ex::forward_progress_guarantee
+    {
       return fpg;
     }
   };
 
-  TEST_CASE("get_forward_progress_guarantee ", "[sched_queries][get_forward_progress_guarantee]") {
-    STATIC_REQUIRE(
-      ex::get_forward_progress_guarantee(uncustomized_scheduler{})
-      == ex::forward_progress_guarantee::weakly_parallel);
-    STATIC_REQUIRE(
-      ex::get_forward_progress_guarantee(
-        customized_scheduler<ex::forward_progress_guarantee::concurrent>{})
-      == ex::forward_progress_guarantee::concurrent);
-    STATIC_REQUIRE(
-      ex::get_forward_progress_guarantee(
-        customized_scheduler<ex::forward_progress_guarantee::parallel>{})
-      == ex::forward_progress_guarantee::parallel);
-    STATIC_REQUIRE(
-      ex::get_forward_progress_guarantee(
-        customized_scheduler<ex::forward_progress_guarantee::weakly_parallel>{})
-      == ex::forward_progress_guarantee::weakly_parallel);
+  TEST_CASE("get_forward_progress_guarantee ", "[sched_queries][get_forward_progress_guarantee]")
+  {
+    STATIC_REQUIRE(ex::get_forward_progress_guarantee(uncustomized_scheduler{})
+                   == ex::forward_progress_guarantee::weakly_parallel);
+    STATIC_REQUIRE(ex::get_forward_progress_guarantee(
+                     customized_scheduler<ex::forward_progress_guarantee::concurrent>{})
+                   == ex::forward_progress_guarantee::concurrent);
+    STATIC_REQUIRE(ex::get_forward_progress_guarantee(
+                     customized_scheduler<ex::forward_progress_guarantee::parallel>{})
+                   == ex::forward_progress_guarantee::parallel);
+    STATIC_REQUIRE(ex::get_forward_progress_guarantee(
+                     customized_scheduler<ex::forward_progress_guarantee::weakly_parallel>{})
+                   == ex::forward_progress_guarantee::weakly_parallel);
   }
 
-} // namespace
+}  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/stdexec/schedulers/test_parallel_scheduler.cpp b/test/stdexec/schedulers/test_parallel_scheduler.cpp
index 66503aa52..71b9b7430 100644
--- a/test/stdexec/schedulers/test_parallel_scheduler.cpp
+++ b/test/stdexec/schedulers/test_parallel_scheduler.cpp
@@ -27,49 +27,54 @@
 #include <catch2/catch.hpp>
 #include <test_common/receivers.hpp>
 
-namespace ex = STDEXEC;
+namespace ex  = STDEXEC;
 namespace scr = ex::system_context_replaceability;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wdeprecated-declarations")
-STDEXEC_PRAGMA_IGNORE_MSVC(4996) // warning C4996: 'function': was declared deprecated
+STDEXEC_PRAGMA_IGNORE_MSVC(4996)  // warning C4996: 'function': was declared deprecated
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity)
 STDEXEC_PRAGMA_IGNORE_EDG(deprecated_entity_with_custom_message)
 
-TEST_CASE("system_context can return a scheduler", "[scheduler][parallel_scheduler]") {
+TEST_CASE("system_context can return a scheduler", "[scheduler][parallel_scheduler]")
+{
   auto sched = STDEXEC::get_parallel_scheduler();
   STATIC_REQUIRE(ex::scheduler<decltype(sched)>);
 }
 
-TEST_CASE("system scheduler is not default constructible", "[scheduler][parallel_scheduler]") {
-  auto sched = STDEXEC::get_parallel_scheduler();
+TEST_CASE("system scheduler is not default constructible", "[scheduler][parallel_scheduler]")
+{
+  auto sched    = STDEXEC::get_parallel_scheduler();
   using sched_t = decltype(sched);
   STATIC_REQUIRE(!std::is_default_constructible_v<sched_t>);
   STATIC_REQUIRE(std::is_destructible_v<sched_t>);
 }
 
-TEST_CASE("system scheduler is copyable and movable", "[scheduler][parallel_scheduler]") {
-  auto sched = STDEXEC::get_parallel_scheduler();
+TEST_CASE("system scheduler is copyable and movable", "[scheduler][parallel_scheduler]")
+{
+  auto sched    = STDEXEC::get_parallel_scheduler();
   using sched_t = decltype(sched);
   STATIC_REQUIRE(std::is_copy_constructible_v<sched_t>);
   STATIC_REQUIRE(std::is_move_constructible_v<sched_t>);
 }
 
-TEST_CASE("a copied scheduler is equal to the original", "[scheduler][parallel_scheduler]") {
+TEST_CASE("a copied scheduler is equal to the original", "[scheduler][parallel_scheduler]")
+{
   auto sched1 = STDEXEC::get_parallel_scheduler();
   auto sched2 = sched1;
   REQUIRE(sched1 == sched2);
 }
 
-TEST_CASE(
-  "two schedulers obtained from get_parallel_scheduler() are equal",
-  "[scheduler][parallel_scheduler]") {
+TEST_CASE("two schedulers obtained from get_parallel_scheduler() are equal",
+          "[scheduler][parallel_scheduler]")
+{
   auto sched1 = STDEXEC::get_parallel_scheduler();
   auto sched2 = STDEXEC::get_parallel_scheduler();
   REQUIRE(sched1 == sched2);
 }
 
-TEST_CASE("system scheduler can produce a sender", "[scheduler][parallel_scheduler]") {
-  auto snd = ex::schedule(STDEXEC::get_parallel_scheduler());
+TEST_CASE("system scheduler can produce a sender", "[scheduler][parallel_scheduler]")
+{
+  auto snd       = ex::schedule(STDEXEC::get_parallel_scheduler());
   using sender_t = decltype(snd);
 
   STATIC_REQUIRE(ex::sender<sender_t>);
@@ -77,15 +82,17 @@ TEST_CASE("system scheduler can produce a sender", "[scheduler][parallel_schedul
   STATIC_REQUIRE(ex::sender_of<sender_t, ex::set_stopped_t()>);
 }
 
-TEST_CASE("trivial schedule task on system context", "[scheduler][parallel_scheduler]") {
+TEST_CASE("trivial schedule task on system context", "[scheduler][parallel_scheduler]")
+{
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   ex::sync_wait(ex::schedule(sched));
 }
 
-TEST_CASE("simple schedule task on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  std::thread::id pool_id{};
+TEST_CASE("simple schedule task on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id = std::this_thread::get_id();
+  std::thread::id             pool_id{};
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   auto snd = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
@@ -97,23 +104,26 @@ TEST_CASE("simple schedule task on system context", "[scheduler][parallel_schedu
   (void) snd;
 }
 
-TEST_CASE("simple schedule forward progress guarantee", "[scheduler][parallel_scheduler]") {
+TEST_CASE("simple schedule forward progress guarantee", "[scheduler][parallel_scheduler]")
+{
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
   REQUIRE(ex::get_forward_progress_guarantee(sched) == ex::forward_progress_guarantee::parallel);
 }
 
-TEST_CASE("get_completion_scheduler", "[scheduler][parallel_scheduler]") {
+TEST_CASE("get_completion_scheduler", "[scheduler][parallel_scheduler]")
+{
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
   REQUIRE(ex::get_completion_scheduler<ex::set_value_t>(ex::get_env(ex::schedule(sched))) == sched);
 }
 
-TEST_CASE("simple chain task on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  std::thread::id pool_id{};
-  std::thread::id pool_id2{};
+TEST_CASE("simple chain task on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id = std::this_thread::get_id();
+  std::thread::id             pool_id{};
+  std::thread::id             pool_id2{};
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto snd = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
+  auto snd  = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
   auto snd2 = ex::then(std::move(snd), [&] { pool_id2 = std::this_thread::get_id(); });
 
   ex::sync_wait(std::move(snd2));
@@ -125,7 +135,8 @@ TEST_CASE("simple chain task on system context", "[scheduler][parallel_scheduler
   (void) snd2;
 }
 
-TEST_CASE("checks stop_token before starting the work", "[scheduler][parallel_scheduler]") {
+TEST_CASE("checks stop_token before starting the work", "[scheduler][parallel_scheduler]")
+{
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   exec::async_scope scope;
@@ -133,7 +144,7 @@ TEST_CASE("checks stop_token before starting the work", "[scheduler][parallel_sc
   REQUIRE(scope.get_stop_source().stop_requested());
 
   bool called = false;
-  auto snd = ex::then(ex::schedule(sched), [&called] { called = true; });
+  auto snd    = ex::then(ex::schedule(sched), [&called] { called = true; });
 
   // Start the sender in a stopped scope
   scope.spawn(std::move(snd));
@@ -145,42 +156,51 @@ TEST_CASE("checks stop_token before starting the work", "[scheduler][parallel_sc
   REQUIRE_FALSE(called);
 }
 
-TEST_CASE("simple bulk task on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  constexpr size_t num_tasks = 16;
-  std::thread::id pool_ids[num_tasks];
+TEST_CASE("simple bulk task on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id   = std::this_thread::get_id();
+  constexpr size_t            num_tasks = 16;
+  std::thread::id             pool_ids[num_tasks];
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto bulk_snd = ex::bulk(ex::schedule(sched), ex::par, num_tasks, [&](size_t id) {
-    pool_ids[id] = std::this_thread::get_id();
-  });
+  auto bulk_snd = ex::bulk(ex::schedule(sched),
+                           ex::par,
+                           num_tasks,
+                           [&](size_t id) { pool_ids[id] = std::this_thread::get_id(); });
 
   ex::sync_wait(std::move(bulk_snd));
 
-  for (auto pool_id: pool_ids) {
+  for (auto pool_id: pool_ids)
+  {
     REQUIRE(pool_id != std::thread::id{});
     REQUIRE(this_id != pool_id);
   }
 }
 
-TEST_CASE("simple bulk chaining on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  constexpr size_t num_tasks = 16;
-  std::thread::id pool_id{};
-  std::thread::id propagated_pool_ids[num_tasks];
-  std::thread::id pool_ids[num_tasks];
+TEST_CASE("simple bulk chaining on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id   = std::this_thread::get_id();
+  constexpr size_t            num_tasks = 16;
+  std::thread::id             pool_id{};
+  std::thread::id             propagated_pool_ids[num_tasks];
+  std::thread::id             pool_ids[num_tasks];
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto snd = ex::then(ex::schedule(sched), [&] {
-    pool_id = std::this_thread::get_id();
-    return pool_id;
-  });
-
-  auto bulk_snd = ex::bulk(
-    std::move(snd), ex::par, num_tasks, [&](size_t id, std::thread::id propagated_pool_id) {
-      propagated_pool_ids[id] = propagated_pool_id;
-      pool_ids[id] = std::this_thread::get_id();
-    });
+  auto snd = ex::then(ex::schedule(sched),
+                      [&]
+                      {
+                        pool_id = std::this_thread::get_id();
+                        return pool_id;
+                      });
+
+  auto bulk_snd = ex::bulk(std::move(snd),
+                           ex::par,
+                           num_tasks,
+                           [&](size_t id, std::thread::id propagated_pool_id)
+                           {
+                             propagated_pool_ids[id] = propagated_pool_id;
+                             pool_ids[id]            = std::this_thread::get_id();
+                           });
 
   std::optional<std::tuple<std::thread::id>> res = ex::sync_wait(std::move(bulk_snd));
 
@@ -188,7 +208,8 @@ TEST_CASE("simple bulk chaining on system context", "[scheduler][parallel_schedu
   REQUIRE(pool_id != std::thread::id{});
   REQUIRE(this_id != pool_id);
   // Assert: bulk items are run and they propagate the received value.
-  for (size_t i = 0; i < num_tasks; ++i) {
+  for (size_t i = 0; i < num_tasks; ++i)
+  {
     REQUIRE(pool_ids[i] != std::thread::id{});
     REQUIRE(propagated_pool_ids[i] == pool_id);
     REQUIRE(this_id != pool_ids[i]);
@@ -198,130 +219,160 @@ TEST_CASE("simple bulk chaining on system context", "[scheduler][parallel_schedu
   CHECK(std::get<0>(res.value()) == pool_id);
 }
 
-TEST_CASE("simple bulk_chunked task on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  constexpr unsigned long num_tasks = 16;
-  std::thread::id pool_ids[num_tasks];
+TEST_CASE("simple bulk_chunked task on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id   = std::this_thread::get_id();
+  constexpr unsigned long     num_tasks = 16;
+  std::thread::id             pool_ids[num_tasks];
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto bulk_snd = ex::bulk_chunked(
-    ex::schedule(sched), ex::par, num_tasks, [&](unsigned long b, unsigned long e) {
-      for (unsigned long id = b; id < e; ++id)
-        pool_ids[id] = std::this_thread::get_id();
-    });
+  auto bulk_snd = ex::bulk_chunked(ex::schedule(sched),
+                                   ex::par,
+                                   num_tasks,
+                                   [&](unsigned long b, unsigned long e)
+                                   {
+                                     for (unsigned long id = b; id < e; ++id)
+                                       pool_ids[id] = std::this_thread::get_id();
+                                   });
 
   ex::sync_wait(std::move(bulk_snd));
 
-  for (auto pool_id: pool_ids) {
+  for (auto pool_id: pool_ids)
+  {
     REQUIRE(pool_id != std::thread::id{});
     REQUIRE(this_id != pool_id);
   }
 }
 
-TEST_CASE("simple bulk_unchunked task on system context", "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  constexpr size_t num_tasks = 16;
-  std::thread::id pool_ids[num_tasks];
+TEST_CASE("simple bulk_unchunked task on system context", "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id   = std::this_thread::get_id();
+  constexpr size_t            num_tasks = 16;
+  std::thread::id             pool_ids[num_tasks];
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto bulk_snd = ex::bulk_unchunked(ex::schedule(sched), ex::par, num_tasks, [&](size_t id) {
-    pool_ids[id] = std::this_thread::get_id();
-  });
+  auto bulk_snd = ex::bulk_unchunked(ex::schedule(sched),
+                                     ex::par,
+                                     num_tasks,
+                                     [&](size_t id) { pool_ids[id] = std::this_thread::get_id(); });
 
   ex::sync_wait(std::move(bulk_snd));
 
-  for (auto pool_id: pool_ids) {
+  for (auto pool_id: pool_ids)
+  {
     REQUIRE(pool_id != std::thread::id{});
     REQUIRE(this_id != pool_id);
   }
 }
 
-TEST_CASE(
-  "bulk_unchunked with seq will run everything on one thread",
-  "[scheduler][parallel_scheduler]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  constexpr size_t num_tasks = 16;
-  std::thread::id pool_ids[num_tasks];
+TEST_CASE("bulk_unchunked with seq will run everything on one thread",
+          "[scheduler][parallel_scheduler]")
+{
+  std::thread::id             this_id   = std::this_thread::get_id();
+  constexpr size_t            num_tasks = 16;
+  std::thread::id             pool_ids[num_tasks];
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
-  auto bulk_snd = ex::bulk_unchunked(ex::schedule(sched), ex::seq, num_tasks, [&](size_t id) {
-    pool_ids[id] = std::this_thread::get_id();
-    std::this_thread::sleep_for(std::chrono::milliseconds{1});
-  });
+  auto bulk_snd = ex::bulk_unchunked(ex::schedule(sched),
+                                     ex::seq,
+                                     num_tasks,
+                                     [&](size_t id)
+                                     {
+                                       pool_ids[id] = std::this_thread::get_id();
+                                       std::this_thread::sleep_for(std::chrono::milliseconds{1});
+                                     });
 
   ex::sync_wait(std::move(bulk_snd));
 
-  for (auto pool_id: pool_ids) {
+  for (auto pool_id: pool_ids)
+  {
     REQUIRE(pool_id != std::thread::id{});
     REQUIRE(this_id != pool_id);
-    REQUIRE(pool_id == pool_ids[0]); // All should be the same
+    REQUIRE(pool_id == pool_ids[0]);  // All should be the same
   }
 }
 
-TEST_CASE("bulk_chunked on parallel_scheduler performs chunking", "[scheduler][parallel_scheduler]") {
+TEST_CASE("bulk_chunked on parallel_scheduler performs chunking", "[scheduler][parallel_scheduler]")
+{
   std::atomic<bool> has_chunking = false;
 
-  STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
-  auto bulk_snd = ex::bulk_chunked(ex::schedule(sched), ex::par, 10'000, [&](int b, int e) {
-    if (e - b > 1) {
-      has_chunking = true;
-    }
-  });
+  STDEXEC::parallel_scheduler sched    = STDEXEC::get_parallel_scheduler();
+  auto                        bulk_snd = ex::bulk_chunked(ex::schedule(sched),
+                                   ex::par,
+                                   10'000,
+                                   [&](int b, int e)
+                                   {
+                                     if (e - b > 1)
+                                     {
+                                       has_chunking = true;
+                                     }
+                                   });
   ex::sync_wait(std::move(bulk_snd));
 
   REQUIRE(has_chunking.load());
 }
 
-TEST_CASE(
-  "bulk_chunked on parallel_scheduler covers the entire range",
-  "[scheduler][parallel_scheduler]") {
+TEST_CASE("bulk_chunked on parallel_scheduler covers the entire range",
+          "[scheduler][parallel_scheduler]")
+{
   constexpr size_t num_tasks = 200;
-  bool covered[num_tasks];
-
-  STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
-  auto bulk_snd =
-    ex::bulk_chunked(ex::schedule(sched), ex::par, num_tasks, [&](size_t b, size_t e) {
-      for (auto i = b; i < e; ++i) {
-        covered[i] = true;
-      }
-    });
+  bool             covered[num_tasks];
+
+  STDEXEC::parallel_scheduler sched    = STDEXEC::get_parallel_scheduler();
+  auto                        bulk_snd = ex::bulk_chunked(ex::schedule(sched),
+                                   ex::par,
+                                   num_tasks,
+                                   [&](size_t b, size_t e)
+                                   {
+                                     for (auto i = b; i < e; ++i)
+                                     {
+                                       covered[i] = true;
+                                     }
+                                   });
   ex::sync_wait(std::move(bulk_snd));
 
-  for (size_t i = 0; i < num_tasks; ++i) {
+  for (size_t i = 0; i < num_tasks; ++i)
+  {
     REQUIRE(covered[i]);
   }
 }
 
-TEST_CASE(
-  "bulk_chunked with seq on parallel_scheduler doesn't do chunking",
-  "[scheduler][parallel_scheduler]") {
-  constexpr size_t num_tasks = 200;
+TEST_CASE("bulk_chunked with seq on parallel_scheduler doesn't do chunking",
+          "[scheduler][parallel_scheduler]")
+{
+  constexpr size_t num_tasks       = 200;
   std::atomic<int> execution_count = 0;
 
-  STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
-  auto bulk_snd =
-    ex::bulk_chunked(ex::schedule(sched), ex::seq, num_tasks, [&](size_t b, size_t e) {
-      REQUIRE(b == 0);
-      REQUIRE(e == num_tasks);
-      execution_count++;
-    });
+  STDEXEC::parallel_scheduler sched    = STDEXEC::get_parallel_scheduler();
+  auto                        bulk_snd = ex::bulk_chunked(ex::schedule(sched),
+                                   ex::seq,
+                                   num_tasks,
+                                   [&](size_t b, size_t e)
+                                   {
+                                     REQUIRE(b == 0);
+                                     REQUIRE(e == num_tasks);
+                                     execution_count++;
+                                   });
   ex::sync_wait(std::move(bulk_snd));
 
   REQUIRE(execution_count.load() == 1);
 }
 
 struct my_parallel_scheduler_backend_impl
-  : ex::__system_context_default_impl::__parallel_scheduler_backend_impl {
+  : ex::__system_context_default_impl::__parallel_scheduler_backend_impl
+{
   using base_t = ex::__system_context_default_impl::__parallel_scheduler_backend_impl;
 
   my_parallel_scheduler_backend_impl() = default;
 
   [[nodiscard]]
-  auto num_schedules() const -> int {
+  auto num_schedules() const -> int
+  {
     return count_schedules_;
   }
 
-  void schedule(scr::receiver_proxy& __r, std::span<std::byte> __s) noexcept override {
+  void schedule(scr::receiver_proxy& __r, std::span<std::byte> __s) noexcept override
+  {
     count_schedules_++;
     base_t::schedule(__r, __s);
   }
@@ -331,38 +382,40 @@ struct my_parallel_scheduler_backend_impl
   int count_schedules_ = 0;
 };
 
-struct my_inline_scheduler_backend_impl : scr::parallel_scheduler_backend {
-  void schedule(scr::receiver_proxy& r, std::span<std::byte>) noexcept override {
+struct my_inline_scheduler_backend_impl : scr::parallel_scheduler_backend
+{
+  void schedule(scr::receiver_proxy& r, std::span<std::byte>) noexcept override
+  {
     r.set_value();
   }
 
-  void schedule_bulk_chunked(
-    size_t count,
-    scr::bulk_item_receiver_proxy& r,
-    std::span<std::byte>) noexcept override {
+  void schedule_bulk_chunked(size_t                         count,
+                             scr::bulk_item_receiver_proxy& r,
+                             std::span<std::byte>) noexcept override
+  {
     r.execute(0, count);
     r.set_value();
   }
 
-  void schedule_bulk_unchunked(
-    size_t count,
-    scr::bulk_item_receiver_proxy& r,
-    std::span<std::byte>) noexcept override {
+  void schedule_bulk_unchunked(size_t                         count,
+                               scr::bulk_item_receiver_proxy& r,
+                               std::span<std::byte>) noexcept override
+  {
     for (size_t i = 0; i < count; ++i)
       r.execute(i, i + 1);
     r.set_value();
   }
 };
 
-TEST_CASE(
-  "can change the implementation of system context at runtime",
-  "[scheduler][parallel_scheduler]") {
+TEST_CASE("can change the implementation of system context at runtime",
+          "[scheduler][parallel_scheduler]")
+{
   static auto my_scheduler_backend = std::make_shared<my_parallel_scheduler_backend_impl>();
-  auto old_factory = scr::set_parallel_scheduler_backend(
+  auto        old_factory          = scr::set_parallel_scheduler_backend(
     []() -> std::shared_ptr<scr::parallel_scheduler_backend> { return my_scheduler_backend; });
 
-  std::thread::id this_id = std::this_thread::get_id();
-  std::thread::id pool_id{};
+  std::thread::id             this_id = std::this_thread::get_id();
+  std::thread::id             pool_id{};
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   auto snd = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
@@ -377,16 +430,15 @@ TEST_CASE(
   (void) scr::set_parallel_scheduler_backend(old_factory);
 }
 
-TEST_CASE(
-  "can change the implementation of system context at runtime, with an inline scheduler",
-  "[scheduler][parallel_scheduler]") {
+TEST_CASE("can change the implementation of system context at runtime, with an inline scheduler",
+          "[scheduler][parallel_scheduler]")
+{
   auto old_factory = scr::set_parallel_scheduler_backend(
-    []() -> std::shared_ptr<scr::parallel_scheduler_backend> {
-      return std::make_shared<my_inline_scheduler_backend_impl>();
-    });
+    []() -> std::shared_ptr<scr::parallel_scheduler_backend>
+    { return std::make_shared<my_inline_scheduler_backend_impl>(); });
 
-  std::thread::id this_id = std::this_thread::get_id();
-  std::thread::id pool_id{};
+  std::thread::id             this_id = std::this_thread::get_id();
+  std::thread::id             pool_id{};
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   auto snd = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
@@ -398,19 +450,18 @@ TEST_CASE(
   (void) scr::set_parallel_scheduler_backend(old_factory);
 }
 
-TEST_CASE("empty environment always returns nullopt for any query", "[scheduler][parallel_scheduler]") {
-  struct my_receiver : scr::receiver_proxy {
-    void __query_env(ex::__type_index, ex::__type_index, void*) const noexcept override {
-    }
+TEST_CASE("empty environment always returns nullopt for any query",
+          "[scheduler][parallel_scheduler]")
+{
+  struct my_receiver : scr::receiver_proxy
+  {
+    void __query_env(ex::__type_index, ex::__type_index, void*) const noexcept override {}
 
-    void set_value() noexcept override {
-    }
+    void set_value() noexcept override {}
 
-    void set_error(std::exception_ptr) noexcept override {
-    }
+    void set_error(std::exception_ptr) noexcept override {}
 
-    void set_stopped() noexcept override {
-    }
+    void set_stopped() noexcept override {}
   };
 
   my_receiver rcvr{};
@@ -420,23 +471,24 @@ TEST_CASE("empty environment always returns nullopt for any query", "[scheduler]
   REQUIRE(rcvr.try_query<std::allocator<int>>(ex::get_allocator) == std::nullopt);
 }
 
-TEST_CASE("environment with a stop token can expose its stop token", "[scheduler][parallel_scheduler]") {
-  struct my_receiver : ex::system_context_replaceability::receiver_proxy {
-    void set_value() noexcept override {
-    }
+TEST_CASE("environment with a stop token can expose its stop token",
+          "[scheduler][parallel_scheduler]")
+{
+  struct my_receiver : ex::system_context_replaceability::receiver_proxy
+  {
+    void set_value() noexcept override {}
 
-    void set_error(std::exception_ptr) noexcept override {
-    }
+    void set_error(std::exception_ptr) noexcept override {}
 
-    void set_stopped() noexcept override {
-    }
+    void set_stopped() noexcept override {}
 
    protected:
-    void __query_env(ex::__type_index query, ex::__type_index value, void* dest)
-      const noexcept override {
-      if (
-        query == ex::__mtypeid<ex::get_stop_token_t>
-        && value == ex::__mtypeid<ex::inplace_stop_token>) {
+    void
+    __query_env(ex::__type_index query, ex::__type_index value, void* dest) const noexcept override
+    {
+      if (query == ex::__mtypeid<ex::get_stop_token_t>
+          && value == ex::__mtypeid<ex::inplace_stop_token>)
+      {
         *static_cast<std::optional<ex::inplace_stop_token>*>(dest) = ss.get_token();
       }
     }
diff --git a/test/stdexec/schedulers/test_system_context_replaceability.cpp b/test/stdexec/schedulers/test_system_context_replaceability.cpp
index ee56b0e43..65c4c40b6 100644
--- a/test/stdexec/schedulers/test_system_context_replaceability.cpp
+++ b/test/stdexec/schedulers/test_system_context_replaceability.cpp
@@ -24,40 +24,45 @@
 #  error This should be testing replacement of the system context with weak linking.
 #endif
 
-namespace ex = STDEXEC;
+namespace ex  = STDEXEC;
 namespace scr = ex::system_context_replaceability;
 
-namespace {
+namespace
+{
 
   static int count_schedules = 0;
 
   struct my_parallel_scheduler_backend_impl
-    : ex::__system_context_default_impl::__parallel_scheduler_backend_impl {
+    : ex::__system_context_default_impl::__parallel_scheduler_backend_impl
+  {
     using base_t = ex::__system_context_default_impl::__parallel_scheduler_backend_impl;
 
     my_parallel_scheduler_backend_impl() = default;
 
-    void schedule(scr::receiver_proxy& __r, std::span<std::byte> __s) noexcept override {
+    void schedule(scr::receiver_proxy& __r, std::span<std::byte> __s) noexcept override
+    {
       count_schedules++;
       base_t::schedule(__r, __s);
     }
   };
 
-} // namespace
+}  // namespace
 
-namespace STDEXEC::system_context_replaceability {
+namespace STDEXEC::system_context_replaceability
+{
   // Should replace the function defined in __system_context_default_impl_entry.hpp
   auto query_parallel_scheduler_backend()
-    -> std::shared_ptr<STDEXEC::system_context_replaceability::parallel_scheduler_backend> {
+    -> std::shared_ptr<STDEXEC::system_context_replaceability::parallel_scheduler_backend>
+  {
     return std::make_shared<my_parallel_scheduler_backend_impl>();
   }
-} // namespace STDEXEC::system_context_replaceability
+}  // namespace STDEXEC::system_context_replaceability
 
-TEST_CASE(
-  "Check that we are using a replaced system context (with weak linking)",
-  "[scheduler][parallel_scheduler][replaceability]") {
-  std::thread::id this_id = std::this_thread::get_id();
-  std::thread::id pool_id{};
+TEST_CASE("Check that we are using a replaced system context (with weak linking)",
+          "[scheduler][parallel_scheduler][replaceability]")
+{
+  std::thread::id             this_id = std::this_thread::get_id();
+  std::thread::id             pool_id{};
   STDEXEC::parallel_scheduler sched = STDEXEC::get_parallel_scheduler();
 
   auto snd = ex::then(ex::schedule(sched), [&] { pool_id = std::this_thread::get_id(); });
diff --git a/test/stdexec/schedulers/test_task_scheduler.cpp b/test/stdexec/schedulers/test_task_scheduler.cpp
index 56385142c..56b276566 100644
--- a/test/stdexec/schedulers/test_task_scheduler.cpp
+++ b/test/stdexec/schedulers/test_task_scheduler.cpp
@@ -24,8 +24,10 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("simple task_scheduler test", "[scheduler][task_scheduler]") {
+namespace
+{
+  TEST_CASE("simple task_scheduler test", "[scheduler][task_scheduler]")
+  {
     ex::task_scheduler sched{dummy_scheduler{}};
     STATIC_REQUIRE(ex::scheduler<decltype(sched)>);
     auto sndr = sched.schedule();
@@ -35,75 +37,80 @@ namespace {
     // The receiver checks that it's called
   }
 
-  TEST_CASE(
-    "task_scheduler starts work on the correct execution context",
-    "[scheduler][task_scheduler]") {
+  TEST_CASE("task_scheduler starts work on the correct execution context",
+            "[scheduler][task_scheduler]")
+  {
     exec::single_thread_context ctx;
-    ex::task_scheduler sched{ctx.get_scheduler()};
-    auto sndr = ex::starts_on(sched, ex::just() | ex::then([] {
-                                       return ::std::this_thread::get_id();
-                                     }));
-    auto [tid] = ex::sync_wait(std::move(sndr)).value();
+    ex::task_scheduler          sched{ctx.get_scheduler()};
+    auto                        sndr = ex::starts_on(sched,
+                              ex::just() | ex::then([] { return ::std::this_thread::get_id(); }));
+    auto [tid]                       = ex::sync_wait(std::move(sndr)).value();
     CHECK(tid == ctx.get_thread_id());
   }
 
   static bool g_called = false;
 
   template <class Sndr>
-  struct opaque_sender : private Sndr {
+  struct opaque_sender : private Sndr
+  {
     using sender_concept = ex::sender_t;
     explicit opaque_sender(Sndr sndr)
-      : Sndr{std::move(sndr)} {
-    }
+      : Sndr{std::move(sndr)}
+    {}
     using Sndr::connect;
     using Sndr::get_completion_signatures;
     using Sndr::get_env;
   };
 
-  struct test_domain {
+  struct test_domain
+  {
     template <ex::sender_expr_for<ex::bulk_chunked_t> Sndr, class Env>
-    auto transform_sender(ex::set_value_t, Sndr sndr, const Env&) const {
+    auto transform_sender(ex::set_value_t, Sndr sndr, Env const &) const
+    {
       return ex::then(opaque_sender{std::move(sndr)}, []() noexcept { g_called = true; });
     }
   };
 
-  TEST_CASE(
-    "bulk_unchunked dispatches correctly through task_scheduler",
-    "[scheduler][task_scheduler]") {
+  TEST_CASE("bulk_unchunked dispatches correctly through task_scheduler",
+            "[scheduler][task_scheduler]")
+  {
     ex::task_scheduler sched{dummy_scheduler<test_domain>{}};
-    auto sndr = ex::on(
-      sched, ex::just(-1) | ex::bulk_chunked(ex::par_unseq, 100, [](size_t, size_t, int&) { }));
-    g_called = false;
-    auto [val] = ex::sync_wait(std::move(sndr)).value();
+    auto               sndr = ex::on(sched,
+                       ex::just(-1)
+                         | ex::bulk_chunked(ex::par_unseq, 100, [](size_t, size_t, int &) {}));
+    g_called                = false;
+    auto [val]              = ex::sync_wait(std::move(sndr)).value();
     CHECK(val == -1);
     CHECK(g_called);
   }
 
-  TEST_CASE("bulk dispatches correctly through task_scheduler", "[scheduler][task_scheduler]") {
+  TEST_CASE("bulk dispatches correctly through task_scheduler", "[scheduler][task_scheduler]")
+  {
     ex::task_scheduler sched{dummy_scheduler<test_domain>{}};
-    auto sndr = ex::on(sched, ex::just(-1) | ex::bulk(ex::par_unseq, 100, [](size_t, int&) { }));
-    g_called = false;
+    auto sndr  = ex::on(sched, ex::just(-1) | ex::bulk(ex::par_unseq, 100, [](size_t, int &) {}));
+    g_called   = false;
     auto [val] = ex::sync_wait(std::move(sndr)).value();
     CHECK(val == -1);
     CHECK(g_called);
   }
 
-  TEST_CASE(
-    "task_scheduler cannot be constructed from a parallel_scheduler",
-    "[scheduler][task_scheduler]") {
+  TEST_CASE("task_scheduler cannot be constructed from a parallel_scheduler",
+            "[scheduler][task_scheduler]")
+  {
     STATIC_REQUIRE(!std::is_constructible_v<ex::task_scheduler, ex::parallel_scheduler>);
   }
 
-  TEST_CASE("task_scheduler can deliver a stopped signal", "[scheduler][task_scheduler]") {
+  TEST_CASE("task_scheduler can deliver a stopped signal", "[scheduler][task_scheduler]")
+  {
     ex::inplace_stop_source stop_source;
     stop_source.request_stop();
 
     exec::single_thread_context ctx;
-    ex::task_scheduler sched{ctx.get_scheduler()};
+    ex::task_scheduler          sched{ctx.get_scheduler()};
 
-    auto env = ex::prop{ex::get_stop_token, stop_source.get_token()};
-    auto sndr = ex::schedule(sched) | ex::write_env(env);
+    auto env    = ex::prop{ex::get_stop_token, stop_source.get_token()};
+    auto sndr   = ex::schedule(sched) | ex::write_env(env);
     auto result = ex::sync_wait(std::move(sndr));
     CHECK(!result.has_value());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/types/test_counting_scopes.cpp b/test/stdexec/types/test_counting_scopes.cpp
index 3bc4d63a0..97fc33382 100644
--- a/test/stdexec/types/test_counting_scopes.cpp
+++ b/test/stdexec/types/test_counting_scopes.cpp
@@ -16,9 +16,9 @@
  */
 
 #include <catch2/catch.hpp>
+#include <exec/static_thread_pool.hpp>
 #include <stdexec/execution.hpp>
 #include <test_common/receivers.hpp>
-#include <exec/static_thread_pool.hpp>
 
 #include <atomic>
 #include <concepts>
@@ -34,104 +34,120 @@ namespace ex = STDEXEC;
     ex::simple_counting_scope,                                                                     \
     ex::counting_scope)
 
-namespace {
-  SCOPE_TEST_CASE("the token type satisfies scope_token") {
+namespace
+{
+  SCOPE_TEST_CASE("the token type satisfies scope_token")
+  {
     STATIC_REQUIRE(ex::scope_token<typename TestType::token>);
   }
 
-  SCOPE_TEST_CASE("the association type satisfies scope_association") {
+  SCOPE_TEST_CASE("the association type satisfies scope_association")
+  {
     using assoc_t = decltype(std::declval<TestType&>().get_token().try_associate());
 
     STATIC_REQUIRE(ex::scope_association<assoc_t>);
   }
 
-  SCOPE_TEST_CASE(
-    "the scope type has a static size_t named max_associations with a positive value") {
-    STATIC_REQUIRE(std::same_as<const std::size_t, decltype(TestType::max_associations)>);
+  SCOPE_TEST_CASE("the scope type has a static size_t named max_associations with a positive value")
+  {
+    STATIC_REQUIRE(std::same_as<std::size_t const, decltype(TestType::max_associations)>);
     STATIC_REQUIRE(TestType::max_associations > 0);
   }
 
-  SCOPE_TEST_CASE("the scope type is default-constructible and immovable") {
+  SCOPE_TEST_CASE("the scope type is default-constructible and immovable")
+  {
     STATIC_REQUIRE(std::is_default_constructible_v<TestType>);
     STATIC_REQUIRE(!std::movable<TestType>);
   }
 
-  SCOPE_TEST_CASE("the join-sender is a sender") {
+  SCOPE_TEST_CASE("the join-sender is a sender")
+  {
     TestType scope;
 
     STATIC_REQUIRE(ex::sender<decltype(scope.join())>);
 
     ex::run_loop loop;
-    auto env = ex::prop(ex::get_scheduler, loop.get_scheduler());
+    auto         env = ex::prop(ex::get_scheduler, loop.get_scheduler());
 
     STATIC_REQUIRE(ex::sender_in<decltype(scope.join()), decltype(env)>);
     // the join-sender requires a scheduler in its receiver's environment
     STATIC_REQUIRE(!ex::sender_in<decltype(scope.join()), ex::env<>>);
   }
 
-  SCOPE_TEST_CASE("unused scopes are safe to destroy") {
+  SCOPE_TEST_CASE("unused scopes are safe to destroy")
+  {
     TestType scope;
     (void) scope;
   }
 
-  SCOPE_TEST_CASE("unused-and-closed scopes are safe to destroy") {
+  SCOPE_TEST_CASE("unused-and-closed scopes are safe to destroy")
+  {
     TestType scope;
     scope.close();
   }
 
-  SCOPE_TEST_CASE("joined scopes are safe to destroy") {
+  SCOPE_TEST_CASE("joined scopes are safe to destroy")
+  {
     TestType scope;
     wait_for_value(ex::associate(ex::just(), scope.get_token()));
     wait_for_value(scope.join());
   }
 
-  SCOPE_TEST_CASE("deferred join-senders work") {
+  SCOPE_TEST_CASE("deferred join-senders work")
+  {
     TestType scope;
 
     // grab a reference on the scope
     auto assoc = scope.get_token().try_associate();
     REQUIRE(assoc);
 
-    bool joinStarted = false;
+    bool joinStarted  = false;
     bool joinFinished = false;
 
-    wait_for_value(
-      ex::when_all(
-        ex::just() | ex::let_value([&]() noexcept {
-          // note that we've started evaluating this branch of the when_all
-          joinStarted = true;
-          return scope.join();
-        }) | ex::then([&]() noexcept {
-          // note that join() has completed
-          joinFinished = true;
-        }),
-        ex::just() | ex::then([&]() noexcept {
-          // the whole point is to confirm that join() will suspend if
-          // started with outstanding operation
-          REQUIRE(joinStarted);
-          REQUIRE(!joinFinished);
-          // trigger a disassociation
-          assoc = decltype(assoc){};
-          // resuming the suspended join operation involves scheduling the
-          // resumption on the environment's scheduler, which is a
-          // truly-async process on a run_loop so joinFinished should not
-          // have been updated yet
-          REQUIRE(!joinFinished);
-        })));
+    wait_for_value(ex::when_all(ex::just()
+                                  | ex::let_value(
+                                    [&]() noexcept
+                                    {
+                                      // note that we've started evaluating this branch of the when_all
+                                      joinStarted = true;
+                                      return scope.join();
+                                    })
+                                  | ex::then(
+                                    [&]() noexcept
+                                    {
+                                      // note that join() has completed
+                                      joinFinished = true;
+                                    }),
+                                ex::just()
+                                  | ex::then(
+                                    [&]() noexcept
+                                    {
+                                      // the whole point is to confirm that join() will suspend if
+                                      // started with outstanding operation
+                                      REQUIRE(joinStarted);
+                                      REQUIRE(!joinFinished);
+                                      // trigger a disassociation
+                                      assoc = decltype(assoc){};
+                                      // resuming the suspended join operation involves scheduling the
+                                      // resumption on the environment's scheduler, which is a
+                                      // truly-async process on a run_loop so joinFinished should not
+                                      // have been updated yet
+                                      REQUIRE(!joinFinished);
+                                    })));
 
     REQUIRE(joinStarted);
     REQUIRE(joinFinished);
   }
 
-  SCOPE_TEST_CASE("closed scopes refuse new associations") {
+  SCOPE_TEST_CASE("closed scopes refuse new associations")
+  {
     TestType scope;
 
-    bool firstSenderRan = false;
+    bool firstSenderRan  = false;
     bool secondSenderRan = false;
 
-    ex::sync_wait(
-      ex::associate(ex::just(&firstSenderRan), scope.get_token())
-      | ex::then([](auto* flag) noexcept { *flag = true; }));
+    ex::sync_wait(ex::associate(ex::just(&firstSenderRan), scope.get_token())
+                  | ex::then([](auto* flag) noexcept { *flag = true; }));
 
     // this is a proxy for checking that the scope now needs joining
     REQUIRE(firstSenderRan);
@@ -149,9 +165,10 @@ namespace {
     ex::sync_wait(scope.join());
   }
 
-  SCOPE_TEST_CASE("spawn lots of work looking for TSAN errors") {
+  SCOPE_TEST_CASE("spawn lots of work looking for TSAN errors")
+  {
     exec::static_thread_pool pool;
-    auto sched = pool.get_scheduler();
+    auto                     sched = pool.get_scheduler();
 
     TestType scope;
 
@@ -160,30 +177,40 @@ namespace {
 
     STATIC_REQUIRE(std::size_t(width) * std::size_t(depth) < TestType::max_associations);
 
-    std::atomic<int> opCount{0};
+    std::atomic<int>  opCount{0};
     std::atomic<bool> failed{false};
 
-    auto spawnWork = [&](auto& spawnWork) noexcept -> void {
-      ex::spawn(
-        ex::starts_on(sched, ex::just() | ex::then([&]() noexcept {
-                               auto newOpCount = 1
-                                               + opCount.fetch_add(1, std::memory_order_relaxed);
-                               if (newOpCount >= depth) {
-                                 return;
-                               }
-
-                               for (int i = 0; i < width; ++i) {
-                                 spawnWork(spawnWork);
-                               }
-                             }))
-          | ex::upon_error([&failed](auto&& error) noexcept {
-              WARN("Spawned work failed: " << error);
-              failed = true;
-            }),
-        scope.get_token());
+    auto spawnWork = [&](auto& spawnWork) noexcept -> void
+    {
+      ex::spawn(ex::starts_on(sched,
+                              ex::just()
+                                | ex::then(
+                                  [&]() noexcept
+                                  {
+                                    auto newOpCount = 1
+                                                    + opCount.fetch_add(1,
+                                                                        std::memory_order_relaxed);
+                                    if (newOpCount >= depth)
+                                    {
+                                      return;
+                                    }
+
+                                    for (int i = 0; i < width; ++i)
+                                    {
+                                      spawnWork(spawnWork);
+                                    }
+                                  }))
+                  | ex::upon_error(
+                    [&failed](auto&& error) noexcept
+                    {
+                      WARN("Spawned work failed: " << error);
+                      failed = true;
+                    }),
+                scope.get_token());
     };
 
-    for (int i = 0; i < width; ++i) {
+    for (int i = 0; i < width; ++i)
+    {
       spawnWork(spawnWork);
     }
 
@@ -193,9 +220,10 @@ namespace {
     REQUIRE(!failed);
   }
 
-  SCOPE_TEST_CASE("spawn lots of concurrent join-senders looking for UB") {
+  SCOPE_TEST_CASE("spawn lots of concurrent join-senders looking for UB")
+  {
     exec::static_thread_pool pool;
-    auto sched = pool.get_scheduler();
+    auto                     sched = pool.get_scheduler();
 
     TestType outerScope;
     TestType innerScope;
@@ -207,24 +235,35 @@ namespace {
 
     std::atomic<bool> failed{false};
 
-    for (int i = 0; i < 100; ++i) {
-      ex::spawn(
-        ex::starts_on(sched, innerScope.join()) | ex::upon_error([&](auto error) noexcept {
-          if constexpr (std::same_as<std::exception_ptr, decltype(error)>) {
-            try {
-              std::rethrow_exception(std::move(error));
-            } catch (const std::exception& e) {
-              WARN("failed to spawn: " << e.what());
-            } catch (...) {
-              WARN("failed to spawn with unknown exception");
-            }
-          } else {
-            WARN("failed to spawn: " << error);
-          }
-
-          failed = true;
-        }),
-        outerScope.get_token());
+    for (int i = 0; i < 100; ++i)
+    {
+      ex::spawn(ex::starts_on(sched, innerScope.join())
+                  | ex::upon_error(
+                    [&](auto error) noexcept
+                    {
+                      if constexpr (std::same_as<std::exception_ptr, decltype(error)>)
+                      {
+                        try
+                        {
+                          std::rethrow_exception(std::move(error));
+                        }
+                        catch (std::exception const & e)
+                        {
+                          WARN("failed to spawn: " << e.what());
+                        }
+                        catch (...)
+                        {
+                          WARN("failed to spawn with unknown exception");
+                        }
+                      }
+                      else
+                      {
+                        WARN("failed to spawn: " << error);
+                      }
+
+                      failed = true;
+                    }),
+                outerScope.get_token());
     }
 
     // unblock all the spawned join operations
@@ -235,15 +274,15 @@ namespace {
     REQUIRE(!failed);
   }
 
-  TEST_CASE("counting_scope::request_stop signals associated senders", "[types][counting_scope]") {
+  TEST_CASE("counting_scope::request_stop signals associated senders", "[types][counting_scope]")
+  {
     ex::counting_scope scope;
     scope.request_stop();
 
-    wait_for_value(
-      ex::associate(ex::read_env(ex::get_stop_token), scope.get_token())
-        | ex::then([](auto token) noexcept { return token.stop_requested(); }),
-      true);
+    wait_for_value(ex::associate(ex::read_env(ex::get_stop_token), scope.get_token())
+                     | ex::then([](auto token) noexcept { return token.stop_requested(); }),
+                   true);
 
     ex::sync_wait(scope.join());
   }
-} // namespace
+}  // namespace
diff --git a/test/stdexec/types/test_task.cpp b/test/stdexec/types/test_task.cpp
index f13be7b1d..efcb1030d 100644
--- a/test/stdexec/types/test_task.cpp
+++ b/test/stdexec/types/test_task.cpp
@@ -35,158 +35,185 @@ namespace ex = STDEXEC;
 
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmismatched-new-delete")
 
-namespace {
+namespace
+{
   constinit std::atomic<int> g_thread_id = 0;
-  thread_local const int thread_id = g_thread_id++;
+  thread_local int const     thread_id   = g_thread_id++;
 
   // This is a work-around for apple clang bugs in Release mode
-  [[maybe_unused]]
-  STDEXEC_PP_WHEN(STDEXEC_APPLE_CLANG(), [[clang::optnone]]) auto get_id() -> int {
+  [[maybe_unused]] STDEXEC_PP_WHEN(STDEXEC_APPLE_CLANG(), [[clang::optnone]]) auto get_id() -> int
+  {
     return thread_id;
   }
 
-  TEST_CASE("task is a sender", "[types][task]") {
+  TEST_CASE("task is a sender", "[types][task]")
+  {
     STATIC_REQUIRE(ex::sender<ex::task<void>>);
   }
 
-  auto test_task_void() -> ex::task<void> {
+  auto test_task_void() -> ex::task<void>
+  {
     CHECK(get_id() == 0);
     co_await ex::schedule(ex::inline_scheduler{});
     CHECK(get_id() == 0);
   }
 
-  TEST_CASE("test task<void>", "[types][task]") {
+  TEST_CASE("test task<void>", "[types][task]")
+  {
     auto t = test_task_void();
     ex::sync_wait(std::move(t));
   }
 
-  auto test_task_int() -> ex::task<int> {
+  auto test_task_int() -> ex::task<int>
+  {
     CHECK(get_id() == 0);
     co_await ex::schedule(ex::inline_scheduler{});
     CHECK(get_id() == 0);
     co_return 42;
   }
 
-  TEST_CASE("test task<int>", "[types][task]") {
-    auto t = test_task_int();
+  TEST_CASE("test task<int>", "[types][task]")
+  {
+    auto t   = test_task_int();
     auto [i] = ex::sync_wait(std::move(t)).value();
     CHECK(i == 42);
   }
 
-  auto test_task_int_ref(int& i) -> ex::task<int&> {
+  auto test_task_int_ref(int& i) -> ex::task<int&>
+  {
     CHECK(get_id() == 0);
     co_await ex::schedule(ex::inline_scheduler{});
     CHECK(get_id() == 0);
     co_return i;
   }
 
-  TEST_CASE("test task<int&>", "[types][task]") {
-    int value = 42;
-    auto t = test_task_int_ref(value) | ex::then([](int& i) { return std::ref(i); });
-    auto [i] = ex::sync_wait(std::move(t)).value();
+  TEST_CASE("test task<int&>", "[types][task]")
+  {
+    int  value = 42;
+    auto t     = test_task_int_ref(value) | ex::then([](int& i) { return std::ref(i); });
+    auto [i]   = ex::sync_wait(std::move(t)).value();
     STATIC_REQUIRE(std::same_as<decltype(i), std::reference_wrapper<int>>);
     CHECK(&i.get() == &value);
   }
 
-  struct test_env : ex::env<> {
+  struct test_env : ex::env<>
+  {
     using allocator_type = test_allocator<std::byte>;
   };
 
   template <class Alloc>
   auto test_task_allocator(std::allocator_arg_t, [[maybe_unused]] Alloc alloc)
-    -> ex::task<void, test_env> {
+    -> ex::task<void, test_env>
+  {
     auto alloc2 = co_await ex::read_env(ex::get_allocator);
     STATIC_REQUIRE(std::same_as<decltype(alloc2), test_allocator<std::byte>>);
     CHECK(alloc == alloc2);
     co_return;
   }
 
-  TEST_CASE("test task with allocator", "[types][task]") {
-    size_t bytes = 0;
+  TEST_CASE("test task with allocator", "[types][task]")
+  {
+    size_t   bytes = 0;
     ex::prop env{ex::get_allocator, test_allocator<std::byte>{&bytes}};
-    auto t = test_task_allocator(std::allocator_arg, ex::get_allocator(env));
+    auto     t = test_task_allocator(std::allocator_arg, ex::get_allocator(env));
     CHECK(bytes > 0);
     ex::sync_wait(std::move(t) | ex::write_env(env));
     CHECK(bytes == 0);
   }
 
-  auto test_task_awaits_just_sender() -> ex::task<int> {
+  auto test_task_awaits_just_sender() -> ex::task<int>
+  {
     co_return co_await ex::just(42);
   }
 
-  TEST_CASE("test task can await a just sender", "[types][task]") {
-    auto t = test_task_awaits_just_sender();
+  TEST_CASE("test task can await a just sender", "[types][task]")
+  {
+    auto t   = test_task_awaits_just_sender();
     auto [i] = ex::sync_wait(std::move(t)).value();
     CHECK(i == 42);
   }
 
-  auto test_task_awaits_just_error_sender() -> ex::task<int> {
+  auto test_task_awaits_just_error_sender() -> ex::task<int>
+  {
     co_await ex::just_error(std::runtime_error("error"));
     co_return 42;
   }
 
-  TEST_CASE("test task can await a just error sender", "[types][task]") {
+  TEST_CASE("test task can await a just error sender", "[types][task]")
+  {
     auto t = test_task_awaits_just_error_sender();
     REQUIRE_THROWS_AS(ex::sync_wait(std::move(t)), std::runtime_error);
   }
 
-  auto test_task_awaits_just_stopped_sender() -> ex::task<int> {
+  auto test_task_awaits_just_stopped_sender() -> ex::task<int>
+  {
     co_await ex::just_stopped();
     FAIL("Expected co_awaiting just_stopped to stop the task");
     co_return 42;
   }
 
-  TEST_CASE("test task can await a just stopped sender", "[types][task]") {
-    auto t = test_task_awaits_just_stopped_sender();
+  TEST_CASE("test task can await a just stopped sender", "[types][task]")
+  {
+    auto t   = test_task_awaits_just_stopped_sender();
     auto res = ex::sync_wait(std::move(t));
     CHECK(!res.has_value());
   }
 
   // A sender type that does not claim to complete inline:
-  struct just_int : ex::__result_of<ex::just, int> {
+  struct just_int : ex::__result_of<ex::just, int>
+  {
     explicit just_int(int i)
-      : ex::__result_of<ex::just, int>(ex::just(i)) {
-    }
+      : ex::__result_of<ex::just, int>(ex::just(i))
+    {}
 
     [[nodiscard]]
-    auto get_env() const noexcept {
+    auto get_env() const noexcept
+    {
       return ex::env{};
     }
   };
 
   template <ex::scheduler Worker>
-  auto test_task_awaits_task_scheduler(Worker worker) -> ex::task<int> {
+  auto test_task_awaits_task_scheduler(Worker worker) -> ex::task<int>
+  {
     CHECK(get_id() == 0);
-    int i = co_await ex::starts_on(worker, just_int(42) | ex::then([](int i) {
-                                             CHECK(get_id() != 0);
-                                             return i;
-                                           }));
+    int i = co_await ex::starts_on(worker,
+                                   just_int(42)
+                                     | ex::then(
+                                       [](int i)
+                                       {
+                                         CHECK(get_id() != 0);
+                                         return i;
+                                       }));
     CHECK(get_id() == 0);
     co_return i;
   }
 
-  TEST_CASE(
-    "test task can await a just_int sender with affinity to task_scheduler",
-    "[types][task]") {
+  TEST_CASE("test task can await a just_int sender with affinity to task_scheduler",
+            "[types][task]")
+  {
     exec::single_thread_context ctx;
-    auto t = test_task_awaits_task_scheduler(ctx.get_scheduler());
-    auto [i] = ex::sync_wait(std::move(t)).value();
+    auto                        t = test_task_awaits_task_scheduler(ctx.get_scheduler());
+    auto [i]                      = ex::sync_wait(std::move(t)).value();
     CHECK(i == 42);
   }
 
   // Test affinity with a run_loop scheduler, which is infallible but not inline:
-  struct test_env2 {
+  struct test_env2
+  {
     using scheduler_type = ex::run_loop::scheduler;
-    struct environment_type { };
+    struct environment_type
+    {};
 
     template <ex::__not_same_as<environment_type> _Env>
-      requires ex::__callable<ex::get_scheduler_t, const _Env&>
-    explicit test_env2(const _Env& other) noexcept
-      : sch(ex::get_scheduler(other)) {
-    }
+      requires ex::__callable<ex::get_scheduler_t, _Env const &>
+    explicit test_env2(_Env const & other) noexcept
+      : sch(ex::get_scheduler(other))
+    {}
 
     [[nodiscard]]
-    auto query(ex::get_scheduler_t) const noexcept {
+    auto query(ex::get_scheduler_t) const noexcept
+    {
       return sch;
     }
 
@@ -194,20 +221,26 @@ namespace {
   };
 
   template <ex::scheduler Worker>
-  auto test_task_awaits_run_loop_scheduler(Worker worker) -> ex::task<int, test_env2> {
+  auto test_task_awaits_run_loop_scheduler(Worker worker) -> ex::task<int, test_env2>
+  {
     CHECK(get_id() == 0);
-    int i = co_await ex::starts_on(worker, just_int(42) | ex::then([](int i) {
-                                             CHECK(get_id() != 0);
-                                             return i;
-                                           }));
+    int i = co_await ex::starts_on(worker,
+                                   just_int(42)
+                                     | ex::then(
+                                       [](int i)
+                                       {
+                                         CHECK(get_id() != 0);
+                                         return i;
+                                       }));
     CHECK(get_id() == 0);
     co_return i;
   }
 
-  TEST_CASE("test task can await a just_int sender with affinity to run_loop", "[types][task]") {
+  TEST_CASE("test task can await a just_int sender with affinity to run_loop", "[types][task]")
+  {
     exec::single_thread_context ctx;
-    auto t = test_task_awaits_run_loop_scheduler(ctx.get_scheduler());
-    auto [i] = ex::sync_wait(std::move(t)).value();
+    auto                        t = test_task_awaits_run_loop_scheduler(ctx.get_scheduler());
+    auto [i]                      = ex::sync_wait(std::move(t)).value();
     CHECK(i == 42);
   }
 
@@ -227,6 +260,6 @@ namespace {
 
   // TODO: add tests for stop token support in task
 
-} // anonymous namespace
+}  // anonymous namespace
 
-#endif // !STDEXEC_NO_STD_COROUTINES()
+#endif  // !STDEXEC_NO_STD_COROUTINES()
diff --git a/test/test_common/schedulers.hpp b/test/test_common/schedulers.hpp
index d17ecf949..3cebc5298 100644
--- a/test/test_common/schedulers.hpp
+++ b/test/test_common/schedulers.hpp
@@ -141,12 +141,12 @@ namespace
     template <class Receiver>
     struct opstate
     {
-      opstate(std::shared_ptr<data> shared_data, Receiver&& recv)
+      opstate(std::shared_ptr<data> shared_data, Receiver &&recv)
         : data_(std::move(shared_data))
-        , receiver_(static_cast<Receiver&&>(recv))
+        , receiver_(static_cast<Receiver &&>(recv))
       {}
 
-      opstate(opstate&&) = delete;
+      opstate(opstate &&) = delete;
 
       void start() & noexcept
       {
@@ -158,11 +158,11 @@ namespace
           {
             if (ex::get_stop_token(ex::get_env(receiver_)).stop_requested())
             {
-              ex::set_stopped(static_cast<Receiver&&>(receiver_));
+              ex::set_stopped(static_cast<Receiver &&>(receiver_));
             }
             else
             {
-              ex::set_value(static_cast<Receiver&&>(receiver_));
+              ex::set_value(static_cast<Receiver &&>(receiver_));
             }
           });
         data_->cv_.notify_all();
@@ -181,7 +181,7 @@ namespace
       template <class Receiver>
       auto connect(Receiver rcvr) const -> opstate<Receiver>
       {
-        return {data_, static_cast<Receiver&&>(rcvr)};
+        return {data_, static_cast<Receiver &&>(rcvr)};
       }
 
       [[nodiscard]]
@@ -227,7 +227,7 @@ namespace
     {
       void start() & noexcept
       {
-        ex::set_value(static_cast<Receiver&&>(rcvr_));
+        ex::set_value(static_cast<Receiver &&>(rcvr_));
       }
 
       Receiver rcvr_;
@@ -241,7 +241,7 @@ namespace
       template <class Receiver>
       auto connect(Receiver rcvr) const -> opstate<Receiver>
       {
-        return {{}, static_cast<Receiver&&>(rcvr)};
+        return {{}, static_cast<Receiver &&>(rcvr)};
       }
 
       auto get_env() const noexcept
@@ -259,7 +259,7 @@ namespace
     nothrow_copyable_box() noexcept = default;
 
     explicit nothrow_copyable_box(Type value)
-      : value_(std::make_shared<Type>(static_cast<Type&&>(value)))
+      : value_(std::make_shared<Type>(static_cast<Type &&>(value)))
     {}
 
     [[nodiscard]]
@@ -269,7 +269,7 @@ namespace
     }
 
     [[nodiscard]]
-    auto operator==(nothrow_copyable_box const & other) const
+    auto operator==(nothrow_copyable_box const &other) const
       noexcept(noexcept(*value_ == *(other.value_))) -> bool
     {
       if (value_ && other.value_)
@@ -290,7 +290,7 @@ namespace
     nothrow_copyable_box() noexcept = default;
 
     explicit nothrow_copyable_box(Type value) noexcept(ex::__nothrow_copy_constructible<Type>)
-      : value_(static_cast<Type&&>(value))
+      : value_(static_cast<Type &&>(value))
     {}
 
     [[nodiscard]]
@@ -315,7 +315,7 @@ namespace
     error_scheduler() = default;
 
     explicit error_scheduler(Error err)
-      : err_(static_cast<Error&&>(err))
+      : err_(static_cast<Error &&>(err))
     {}
 
     [[nodiscard]]
@@ -339,7 +339,7 @@ namespace
     {
       void start() & noexcept
       {
-        ex::set_error(static_cast<Receiver&&>(rcvr_), Error(err_.value()));
+        ex::set_error(static_cast<Receiver &&>(rcvr_), Error(err_.value()));
       }
 
       Receiver                    rcvr_;
@@ -355,7 +355,7 @@ namespace
       template <class Receiver>
       auto connect(Receiver rcvr) && -> opstate<Receiver>
       {
-        return {{}, static_cast<Receiver&&>(rcvr), std::move(err_)};
+        return {{}, static_cast<Receiver &&>(rcvr), std::move(err_)};
       }
 
       auto get_env() const noexcept
@@ -367,7 +367,7 @@ namespace
     };
 
     error_scheduler(nothrow_copyable_box<Error> err) noexcept
-      : err_(static_cast<nothrow_copyable_box<Error>&&>(err))
+      : err_(static_cast<nothrow_copyable_box<Error> &&>(err))
     {}
 
     nothrow_copyable_box<Error> err_{};
@@ -403,7 +403,7 @@ namespace
     {
       void start() & noexcept
       {
-        ex::set_stopped(static_cast<Receiver&&>(rcvr_));
+        ex::set_stopped(static_cast<Receiver &&>(rcvr_));
       }
 
       Receiver rcvr_;
@@ -418,7 +418,7 @@ namespace
       template <class Receiver>
       auto connect(Receiver rcvr) const -> opstate<Receiver>
       {
-        return {{}, static_cast<Receiver&&>(rcvr)};
+        return {{}, static_cast<Receiver &&>(rcvr)};
       }
 
       [[nodiscard]]
@@ -448,12 +448,12 @@ namespace
       using operation_state_concept = ex::operation_state_t;
 
       constexpr _opstate_t(Rcvr rcvr) noexcept
-        : _rcvr(static_cast<Rcvr&&>(rcvr))
+        : _rcvr(static_cast<Rcvr &&>(rcvr))
       {}
 
       constexpr void start() noexcept
       {
-        ex::set_value(static_cast<Rcvr&&>(_rcvr));
+        ex::set_value(static_cast<Rcvr &&>(_rcvr));
       }
 
       Rcvr _rcvr;
@@ -473,7 +473,7 @@ namespace
       template <class Rcvr>
       constexpr auto connect(Rcvr rcvr) const noexcept -> _opstate_t<Rcvr>
       {
-        return _opstate_t<Rcvr>(static_cast<Rcvr&&>(rcvr));
+        return _opstate_t<Rcvr>(static_cast<Rcvr &&>(rcvr));
       }
 
       [[nodiscard]]
diff --git a/test/test_common/type_helpers.hpp b/test/test_common/type_helpers.hpp
index 3bdac2ea0..7000ebc21 100644
--- a/test/test_common/type_helpers.hpp
+++ b/test/test_common/type_helpers.hpp
@@ -38,7 +38,7 @@ namespace
     std::same_as<ex::__mapply<ex::__msize, Needles>, ex::__mapply<ex::__msize, Haystack>>
     && all_contained_in<Needles, Haystack>;
 
-  template <auto const & Tag, class... Args>
+  template <auto const &Tag, class... Args>
   using result_of_t = ex::__result_of<Tag, Args...>;
 
   //! Used for to make a class non-movable without giving up aggregate initialization
@@ -57,7 +57,7 @@ namespace
       : value_(value)
     {}
 
-    movable(movable&&)                                      = default;
+    movable(movable &&)                                     = default;
     auto operator==(movable const &) const noexcept -> bool = default;
 
     auto value() -> int
@@ -73,16 +73,17 @@ namespace
   {
     potentially_throwing() = default;
 
-    potentially_throwing(potentially_throwing&&) noexcept(false) {}
+    potentially_throwing(potentially_throwing &&) noexcept(false) {}
 
     potentially_throwing(potentially_throwing const &) noexcept(false) = default;
 
-    auto operator=(potentially_throwing&&) noexcept(false) -> potentially_throwing&
+    auto operator=(potentially_throwing &&) noexcept(false) -> potentially_throwing &
     {
       return *this;
     }
 
-    auto operator=(potentially_throwing const &) noexcept(false) -> potentially_throwing& = default;
+    auto
+    operator=(potentially_throwing const &) noexcept(false) -> potentially_throwing & = default;
   };
 
   //! Used for debugging, to generate errors to the console
@@ -96,7 +97,7 @@ namespace
 
   //! Check that the value_types of a sender matches the expected type
   template <class ExpectedValType, class Env = ex::env<>, class S>
-  inline void check_val_types(S&&)
+  inline void check_val_types(S &&)
   {
     using actual_t = ex::value_types_of_t<S, Env, pack, ex::__mset>;
     static_assert(ex::__mset_eq<actual_t, ExpectedValType>);
@@ -104,7 +105,7 @@ namespace
 
   //! Check that the env of a sender matches the expected type
   template <class ExpectedEnvType, class S>
-  inline void check_env_type(S&& snd)
+  inline void check_env_type(S &&snd)
   {
     using actual_t = decltype(ex::get_env(snd));
     static_assert(std::same_as<actual_t, ExpectedEnvType>);
@@ -112,7 +113,7 @@ namespace
 
   //! Check that the error_types of a sender matches the expected type
   template <class ExpectedValType, class Env = ex::env<>, class S>
-  inline void check_err_types(S&&)
+  inline void check_err_types(S &&)
   {
     using actual_t = ex::error_types_of_t<S, Env, ex::__mset>;
     static_assert(ex::__mset_eq<actual_t, ExpectedValType>);
@@ -120,7 +121,7 @@ namespace
 
   //! Check that the sends_stopped of a sender matches the expected value
   template <bool Expected, class Env = ex::env<>, class S>
-  inline void check_sends_stopped(S&&)
+  inline void check_sends_stopped(S &&)
   {
     constexpr bool actual = ex::sends_stopped<S, Env>;
     static_assert(actual == Expected);
diff --git a/test/test_scratch.cpp b/test/test_scratch.cpp
index bc9304054..6b933c0e6 100644
--- a/test/test_scratch.cpp
+++ b/test/test_scratch.cpp
@@ -22,8 +22,10 @@
 
 namespace ex = STDEXEC;
 
-namespace {
-  TEST_CASE("a scratch test case for minimal repro of a bug", "[scratch]") {
+namespace
+{
+  TEST_CASE("a scratch test case for minimal repro of a bug", "[scratch]")
+  {
     CHECK(true);
   }
-} // namespace
+}  // namespace