diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/is_heap.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/is_heap.hpp
index 9fef38be730..70d1817bf63 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/is_heap.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/is_heap.hpp
@@ -263,9 +263,8 @@ namespace hpx::parallel {
         {
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename Comp, typename Proj>
-            decltype(auto) operator()(
-                ExPolicy&& orgpolicy, Iter first, Sent last, Comp&& comp,
-                Proj&& proj)
+            decltype(auto) operator()(ExPolicy&& orgpolicy, Iter first,
+                Sent last, Comp&& comp, Proj&& proj)
             {
                 using result = util::detail::algorithm_result<ExPolicy, bool>;
                 using type = typename std::iterator_traits<Iter>::value_type;
@@ -283,7 +282,8 @@ namespace hpx::parallel {
                         // underflow prevention
                         ++count;
                     }
-                } else
+                }
+                else
                 {
                     if (count <= 1)
                     {
@@ -362,9 +362,8 @@ namespace hpx::parallel {
 
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename Comp, typename Proj>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, Iter first, Sent last, Comp&& comp,
-                Proj&& proj)
+            static decltype(auto) parallel(ExPolicy&& policy, Iter first,
+                Sent last, Comp&& comp, Proj&& proj)
             {
                 return is_heap_helper()(HPX_FORWARD(ExPolicy, policy), first,
                     last, HPX_FORWARD(Comp, comp), HPX_FORWARD(Proj, proj));
@@ -399,9 +398,8 @@ namespace hpx::parallel {
         {
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename Comp, typename Proj>
-            decltype(auto) operator()(
-                ExPolicy&& orgpolicy, Iter first, Sent last, Comp comp,
-                Proj proj)
+            decltype(auto) operator()(ExPolicy&& orgpolicy, Iter first,
+                Sent last, Comp comp, Proj proj)
             {
                 using result = util::detail::algorithm_result<ExPolicy, Iter>;
                 using type = typename std::iterator_traits<Iter>::value_type;
@@ -419,11 +417,13 @@ namespace hpx::parallel {
                     {
                         count = 0;
                         second = last;
-                    } else
+                    }
+                    else
                     {
                         return result::get(HPX_MOVE(last));
                     }
-                } else
+                }
+                else
                 {
                     second = first + 1;
                     --count;
@@ -500,9 +500,8 @@ namespace hpx::parallel {
 
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename Comp, typename Proj>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, Iter first, Sent last, Comp&& comp,
-                Proj&& proj)
+            static decltype(auto) parallel(ExPolicy&& policy, Iter first,
+                Sent last, Comp&& comp, Proj&& proj)
             {
                 return is_heap_until_helper()(HPX_FORWARD(ExPolicy, policy),
                     first, last, HPX_FORWARD(Comp, comp),
@@ -532,9 +531,8 @@ namespace hpx {
                 >
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(is_heap_t, ExPolicy&& policy, RandIter first,
-            RandIter last, Comp comp = Comp())
+        friend decltype(auto) tag_fallback_invoke(is_heap_t, ExPolicy&& policy,
+            RandIter first, RandIter last, Comp comp = Comp())
         {
             static_assert(hpx::traits::is_random_access_iterator_v<RandIter>,
                 "Requires a random access iterator.");
@@ -585,9 +583,9 @@ namespace hpx {
                 >
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(is_heap_until_t, ExPolicy&& policy, RandIter first,
-            RandIter last, Comp comp = Comp())
+        friend decltype(auto) tag_fallback_invoke(is_heap_until_t,
+            ExPolicy&& policy, RandIter first, RandIter last,
+            Comp comp = Comp())
         {
             static_assert(hpx::traits::is_random_access_iterator_v<RandIter>,
                 "Requires a random access iterator.");
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/is_partitioned.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/is_partitioned.hpp
index 5d16c18c19d..1037e92c515 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/is_partitioned.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/is_partitioned.hpp
@@ -178,9 +178,8 @@ namespace hpx::parallel {
             }
 
             template <typename ExPolicy, typename Pred, typename Proj>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, Iter first, Sent last, Pred&& pred,
-                Proj&& proj)
+            static decltype(auto) parallel(ExPolicy&& policy, Iter first,
+                Sent last, Pred&& pred, Proj&& proj)
             {
                 using difference_type =
                     typename std::iterator_traits<Iter>::difference_type;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/is_sorted.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/is_sorted.hpp
index d519e5474bd..7c1cd8633b3 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/is_sorted.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/is_sorted.hpp
@@ -272,9 +272,8 @@ namespace hpx::parallel {
             }
 
             template <typename ExPolicy, typename Pred, typename Proj>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, FwdIter first, Sent last, Pred&& pred,
-                Proj&& proj)
+            static decltype(auto) parallel(ExPolicy&& policy, FwdIter first,
+                Sent last, Pred&& pred, Proj&& proj)
             {
                 using difference_type =
                     typename std::iterator_traits<FwdIter>::difference_type;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/mismatch.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/mismatch.hpp
index f4063f05a8b..80097d6e561 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/mismatch.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/mismatch.hpp
@@ -593,9 +593,9 @@ namespace hpx::parallel {
             template <typename ExPolicy, typename Iter1, typename Sent1,
                 typename Iter2, typename Sent2, typename F, typename Proj1,
                 typename Proj2>
-            static decltype(auto)
-            parallel(ExPolicy&& orgpolicy, Iter1 first1, Sent1 last1,
-                Iter2 first2, Sent2 last2, F&& f, Proj1&& proj1, Proj2&& proj2)
+            static decltype(auto) parallel(ExPolicy&& orgpolicy, Iter1 first1,
+                Sent1 last1, Iter2 first2, Sent2 last2, F&& f, Proj1&& proj1,
+                Proj2&& proj2)
             {
                 constexpr bool has_scheduler_executor =
                     hpx::execution_policy_has_scheduler_executor_v<ExPolicy>;
@@ -605,8 +605,8 @@ namespace hpx::parallel {
                     if (first1 == last1 || first2 == last2)
                     {
                         return util::detail::algorithm_result<ExPolicy,
-                            util::in_in_result<Iter1, Iter2>>::
-                            get(util::in_in_result<Iter1, Iter2>{first1, first2});
+                            util::in_in_result<Iter1, Iter2>>::get(util::
+                                in_in_result<Iter1, Iter2>{first1, first2});
                     }
                 }
 
@@ -622,8 +622,7 @@ namespace hpx::parallel {
 
                 using policy_type = std::decay_t<decltype(policy)>;
 
-                hpx::parallel::util::cancellation_token<std::size_t> tok(
-                    count);
+                hpx::parallel::util::cancellation_token<std::size_t> tok(count);
 
                 auto f1 = [tok, f = HPX_FORWARD(F, f),
                               proj1 = HPX_FORWARD(Proj1, proj1),
@@ -679,9 +678,10 @@ namespace hpx::parallel {
         decltype(auto) get_pair(InInSender&& in_in_sender) noexcept
         {
             return hpx::execution::experimental::then(
-             HPX_FORWARD(InInSender, in_in_sender), [](auto&& in_in_result) {
-                 return get_pair(HPX_FORWARD(decltype(in_in_result), in_in_result));
-             });
+                HPX_FORWARD(InInSender, in_in_sender), [](auto&& in_in_result) {
+                    return get_pair(
+                        HPX_FORWARD(decltype(in_in_result), in_in_result));
+                });
         }
 
         template <typename I1, typename I2>
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/remove.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/remove.hpp
index 27f1f465e5a..5bd439c6689 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/remove.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/remove.hpp
@@ -329,8 +329,7 @@ namespace hpx::parallel {
                         });
                 };
 
-                auto f2 =
-                    [flags, first, count](auto&&...) mutable -> Iter {
+                auto f2 = [flags, first, count](auto&&...) mutable -> Iter {
                     auto part_begin = zip_iterator(first, flags.get());
                     auto dest = first;
                     auto part_size = count;
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/rotate.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/rotate.hpp
index be67a132449..6e396505719 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/rotate.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/rotate.hpp
@@ -390,9 +390,8 @@ namespace hpx::parallel {
 
         template <typename ExPolicy, typename FwdIter1, typename Sent,
             typename FwdIter2>
-        decltype(auto) rotate_copy_helper(
-            ExPolicy policy, FwdIter1 first, FwdIter1 new_first, Sent last,
-            FwdIter2 dest_first)
+        decltype(auto) rotate_copy_helper(ExPolicy policy, FwdIter1 first,
+            FwdIter1 new_first, Sent last, FwdIter2 dest_first)
         {
             constexpr bool has_scheduler_executor =
                 hpx::execution_policy_has_scheduler_executor_v<ExPolicy>;
@@ -403,31 +402,31 @@ namespace hpx::parallel {
             if constexpr (!has_scheduler_executor)
             {
                 auto p = hpx::execution::parallel_task_policy()
-                         .on(policy.executor())
-                         .with(policy.parameters());
+                             .on(policy.executor())
+                             .with(policy.parameters());
 
                 hpx::future<copy_return_type> f =
                     detail::copy<copy_return_type>().call2(
                         p, non_seq(), new_first, last, dest_first);
 
-                return f.then([p, first, new_first](hpx::future<copy_return_type>&& result)
+                return f.then([p, first, new_first](
+                                  hpx::future<copy_return_type>&& result)
                                   -> hpx::future<copy_return_type> {
                     copy_return_type p1 = result.get();
                     return detail::copy<copy_return_type>().call2(
                         p, non_seq(), first, new_first, p1.out);
                 });
-            } else
+            }
+            else
             {
                 return detail::copy<copy_return_type>().call(
-                        policy, new_first, last, dest_first)
-                | hpx::execution::experimental::let_value(
-                    [policy, first, new_first](copy_return_type& result) {
-                        return detail::copy<copy_return_type>().call(
-                        policy, first, new_first, result.out);
-                    }
-                );
+                           policy, new_first, last, dest_first) |
+                    hpx::execution::experimental::let_value(
+                        [policy, first, new_first](copy_return_type& result) {
+                            return detail::copy<copy_return_type>().call(
+                                policy, first, new_first, result.out);
+                        });
             }
-
         }
 
         template <typename IterPair>
@@ -450,9 +449,8 @@ namespace hpx::parallel {
 
             template <typename ExPolicy, typename FwdIter1, typename Sent,
                 typename FwdIter2>
-            static decltype(auto)
-            parallel(ExPolicy&& policy, FwdIter1 first, FwdIter1 new_first,
-                Sent last, FwdIter2 dest_first)
+            static decltype(auto) parallel(ExPolicy&& policy, FwdIter1 first,
+                FwdIter1 new_first, Sent last, FwdIter2 dest_first)
             {
                 return util::detail::algorithm_result<ExPolicy, IterPair>::get(
                     rotate_copy_helper(HPX_FORWARD(ExPolicy, policy), first,
@@ -578,10 +576,9 @@ namespace hpx {
                 hpx::traits::is_iterator_v<FwdIter2>
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(hpx::rotate_copy_t, ExPolicy&& policy,
-            FwdIter1 first, FwdIter1 new_first, FwdIter1 last,
-            FwdIter2 dest_first)
+        friend decltype(auto) tag_fallback_invoke(hpx::rotate_copy_t,
+            ExPolicy&& policy, FwdIter1 first, FwdIter1 new_first,
+            FwdIter1 last, FwdIter2 dest_first)
         {
             static_assert(hpx::traits::is_forward_iterator_v<FwdIter1>,
                 "Requires at least forward iterator.");
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/starts_with.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/starts_with.hpp
index 180999f2100..dea00aea6f4 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/starts_with.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/starts_with.hpp
@@ -213,10 +213,9 @@ namespace hpx::parallel {
 
                 auto end_first = std::next(first1, dist2);
 
-                return detail::equal_binary{}.call(hpx::execution::seq,
-                    first1, end_first, first2,
-                        last2, HPX_FORWARD(Pred, pred),
-                        HPX_FORWARD(Proj1, proj1), HPX_FORWARD(Proj2, proj2));
+                return detail::equal_binary{}.call(hpx::execution::seq, first1,
+                    end_first, first2, last2, HPX_FORWARD(Pred, pred),
+                    HPX_FORWARD(Proj1, proj1), HPX_FORWARD(Proj2, proj2));
             }
 
             template <typename ExPolicy, typename FwdIter1, typename Sent1,
@@ -239,10 +238,11 @@ namespace hpx::parallel {
                         // make sure that the two ranges passed to equal_binary
                         // have different length to get `false` as return value
                         dist2 = 0;
-                    } else
+                    }
+                    else
                     {
                         return util::detail::algorithm_result<ExPolicy,
-                        bool>::get(false);
+                            bool>::get(false);
                     }
                 }
 
@@ -250,8 +250,8 @@ namespace hpx::parallel {
 
                 return detail::equal_binary{}.call(
                     HPX_FORWARD(ExPolicy, policy), first1, end_first, first2,
-                        last2, HPX_FORWARD(Pred, pred),
-                        HPX_FORWARD(Proj1, proj1), HPX_FORWARD(Proj2, proj2));
+                    last2, HPX_FORWARD(Pred, pred), HPX_FORWARD(Proj1, proj1),
+                    HPX_FORWARD(Proj2, proj2));
             }
         };
         /// \endcond
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/transform_reduce.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/transform_reduce.hpp
index 52979caf0b7..ed6ba8511b2 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/transform_reduce.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/transform_reduce.hpp
@@ -470,9 +470,8 @@ namespace hpx::parallel {
 
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename T_, typename Reduce, typename Convert>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, Iter first, Sent last, T_&& init, Reduce&& r,
-                Convert&& conv)
+            static decltype(auto) parallel(ExPolicy&& policy, Iter first,
+                Sent last, T_&& init, Reduce&& r, Convert&& conv)
             {
                 constexpr bool has_scheduler_executor =
                     hpx::execution_policy_has_scheduler_executor_v<ExPolicy>;
@@ -533,9 +532,8 @@ namespace hpx::parallel {
 
             template <typename ExPolicy, typename Iter, typename Sent,
                 typename Iter2, typename T_, typename Op1, typename Op2>
-            static decltype(auto) parallel(
-                ExPolicy&& policy, Iter first1, Sent last1, Iter2 first2,
-                T_&& init, Op1&& op1, Op2&& op2)
+            static decltype(auto) parallel(ExPolicy&& policy, Iter first1,
+                Sent last1, Iter2 first2, T_&& init, Op1&& op1, Op2&& op2)
             {
                 using result = util::detail::algorithm_result<ExPolicy, T>;
                 using zip_iterator = hpx::util::zip_iterator<Iter, Iter2>;
@@ -553,7 +551,6 @@ namespace hpx::parallel {
                     }
                 }
 
-
                 difference_type count = detail::distance(first1, last1);
 
                 auto f1 = [op1, op2 = HPX_FORWARD(Op2, op2)](
@@ -583,8 +580,8 @@ namespace hpx::parallel {
                         T ret = HPX_MOVE(init);
                         for (auto&& result : results)
                         {
-                            ret = HPX_INVOKE(op1, HPX_MOVE(ret),
-                                hpx::unwrap(result));
+                            ret = HPX_INVOKE(
+                                op1, HPX_MOVE(ret), hpx::unwrap(result));
                         }
                         return ret;
                     });
@@ -619,9 +616,9 @@ namespace hpx {
                 >
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(transform_reduce_t, ExPolicy&& policy,
-            FwdIter first, FwdIter last, T init, Reduce red_op, Convert conv_op)
+        friend decltype(auto) tag_fallback_invoke(transform_reduce_t,
+            ExPolicy&& policy, FwdIter first, FwdIter last, T init,
+            Reduce red_op, Convert conv_op)
         {
             static_assert(hpx::traits::is_forward_iterator_v<FwdIter>,
                 "Requires at least forward iterator.");
@@ -668,9 +665,9 @@ namespace hpx {
                 hpx::traits::is_iterator_v<FwdIter2>
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(transform_reduce_t, ExPolicy&& policy,
-            FwdIter1 first1, FwdIter1 last1, FwdIter2 first2, T init)
+        friend decltype(auto) tag_fallback_invoke(transform_reduce_t,
+            ExPolicy&& policy, FwdIter1 first1, FwdIter1 last1, FwdIter2 first2,
+            T init)
         {
             static_assert(hpx::traits::is_forward_iterator_v<FwdIter1>,
                 "Requires at least forward iterator.");
@@ -727,10 +724,9 @@ namespace hpx {
                 >
             )>
         // clang-format on
-        friend decltype(auto)
-        tag_fallback_invoke(transform_reduce_t, ExPolicy&& policy,
-            FwdIter1 first1, FwdIter1 last1, FwdIter2 first2, T init,
-            Reduce red_op, Convert conv_op)
+        friend decltype(auto) tag_fallback_invoke(transform_reduce_t,
+            ExPolicy&& policy, FwdIter1 first1, FwdIter1 last1, FwdIter2 first2,
+            T init, Reduce red_op, Convert conv_op)
         {
             static_assert(hpx::traits::is_forward_iterator_v<FwdIter1>,
                 "Requires at least forward iterator.");
diff --git a/libs/core/algorithms/include/hpx/parallel/algorithms/unique.hpp b/libs/core/algorithms/include/hpx/parallel/algorithms/unique.hpp
index 35c9171db90..a5b47764b63 100644
--- a/libs/core/algorithms/include/hpx/parallel/algorithms/unique.hpp
+++ b/libs/core/algorithms/include/hpx/parallel/algorithms/unique.hpp
@@ -434,8 +434,7 @@ namespace hpx::parallel {
                         });
                 };
 
-                auto f2 =
-                    [flags, first, count](auto&&...) mutable -> FwdIter {
+                auto f2 = [flags, first, count](auto&&...) mutable -> FwdIter {
                     auto part_begin = zip_iterator(first, flags.get());
                     auto dest = first;
                     auto part_size = count;
diff --git a/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
index c1d55b6a6a7..f1dd36b7d8e 100644
--- a/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/adjacentdifference_tests.hpp
@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/execution.hpp>
 #include <hpx/modules/testing.hpp>
 #include <hpx/numeric.hpp>
diff --git a/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
index 39918e10287..46a9a7602dd 100644
--- a/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/adjacentfind_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 
diff --git a/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
index d327907515f..eb83b57a613 100644
--- a/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/any_of_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 #include <hpx/type_support/identity.hpp>
diff --git a/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
index 831acf622b9..0be1d08c9ed 100644
--- a/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/copyn_tests.hpp
@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 
diff --git a/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
index 0353e169ec3..970e6b0d80f 100644
--- a/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/destroy_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/execution.hpp>
 #include <hpx/memory.hpp>
 #include <hpx/modules/testing.hpp>
diff --git a/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
index c6552809211..aef2a4a4e38 100644
--- a/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/find_tests.hpp
@@ -124,7 +124,6 @@ void test_find_explicit_sender(Policy l, ExPolicy&& policy, IteratorTag)
         ex::just(iterator(std::begin(c)), iterator(std::end(c)), int(1)) |
         hpx::find(policy.on(exec)));
 
-
     base_iterator test_index = std::begin(c) + c.size() / 2;
 
     HPX_TEST(hpx::get<0>(*result) == iterator(test_index));
diff --git a/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
index 9549e79d937..083d4b9c736 100644
--- a/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/generate_tests.hpp
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 
diff --git a/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
index 0880d54df06..493dd4ec76a 100644
--- a/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/generaten_tests.hpp
@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 
diff --git a/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
index 93ffc4a86a8..88b0bc64a30 100644
--- a/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/is_sorted_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/execution.hpp>
 #include <hpx/modules/testing.hpp>
 
diff --git a/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
index aff9a3284e6..1a4f33b9eaf 100644
--- a/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/none_of_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/init.hpp>
 #include <hpx/modules/testing.hpp>
 #include <hpx/type_support/identity.hpp>
diff --git a/libs/core/algorithms/tests/unit/algorithms/reverse_sender.cpp b/libs/core/algorithms/tests/unit/algorithms/reverse_sender.cpp
index 630bb05a273..e6f2eae95b8 100644
--- a/libs/core/algorithms/tests/unit/algorithms/reverse_sender.cpp
+++ b/libs/core/algorithms/tests/unit/algorithms/reverse_sender.cpp
@@ -117,7 +117,6 @@ void test_reverse_async_direct(Policy l, ExPolicy&& p, IteratorTag)
     tt::sync_wait(hpx::reverse(
         p.on(exec), iterator(std::begin(c)), iterator(std::end(c))));
 
-
     std::reverse(std::begin(d1), std::end(d1));
 
     std::size_t count = 0;
diff --git a/libs/core/algorithms/tests/unit/algorithms/rotate_sender.cpp b/libs/core/algorithms/tests/unit/algorithms/rotate_sender.cpp
index d3b5efb595b..72ab77d0fde 100644
--- a/libs/core/algorithms/tests/unit/algorithms/rotate_sender.cpp
+++ b/libs/core/algorithms/tests/unit/algorithms/rotate_sender.cpp
@@ -100,7 +100,6 @@ void test_rotate(Policy l, ExPolicy&& policy, IteratorTag)
                       iterator(std::end(c))) |
         hpx::rotate(policy.on(exec)));
 
-
     base_iterator mid1 = std::begin(d1);
     std::advance(mid1, mid_pos);
     std::rotate(std::begin(d1), mid1, std::end(d1));
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_sender.cpp b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_sender.cpp
index 90eb172ec96..3a8909aecce 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_sender.cpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_sender.cpp
@@ -4,7 +4,6 @@
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-
 #include <hpx/init.hpp>
 
 #include <iostream>
@@ -14,15 +13,17 @@
 
 #include "transform_reduce_binary_tests.hpp"
 
-
 template <typename IteratorTag>
 void transform_reduce_binary_sender_test()
 {
     using namespace hpx::execution;
-    test_transform_reduce_binary_sender(hpx::launch::sync, seq(task), IteratorTag());
-    test_transform_reduce_binary_sender(hpx::launch::sync, unseq(task), IteratorTag());
+    test_transform_reduce_binary_sender(
+        hpx::launch::sync, seq(task), IteratorTag());
+    test_transform_reduce_binary_sender(
+        hpx::launch::sync, unseq(task), IteratorTag());
 
-    test_transform_reduce_binary_sender(hpx::launch::async, par(task), IteratorTag());
+    test_transform_reduce_binary_sender(
+        hpx::launch::async, par(task), IteratorTag());
     test_transform_reduce_binary_sender(
         hpx::launch::async, par_unseq(task), IteratorTag());
 }
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
index 97bc3f1fd01..be43be75c4c 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_binary_tests.hpp
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <hpx/algorithm.hpp>
 #include <hpx/config.hpp>
+#include <hpx/algorithm.hpp>
 #include <hpx/execution.hpp>
 #include <hpx/modules/testing.hpp>
 #include <hpx/numeric.hpp>
diff --git a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_sender.cpp b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_sender.cpp
index 52214493112..b88a6824da5 100644
--- a/libs/core/algorithms/tests/unit/algorithms/transform_reduce_sender.cpp
+++ b/libs/core/algorithms/tests/unit/algorithms/transform_reduce_sender.cpp
@@ -54,10 +54,10 @@ void test_transform_reduce_sender(
     auto exec = ex::explicit_scheduler_executor(scheduler_t(ln_policy));
 
     {
-        auto snd_result =
-           tt::sync_wait(ex::just(iterator(std::begin(c)), iterator(std::end(c)),
-                             init, reduce_op, convert_op) |
-               hpx::transform_reduce(ex_policy.on(exec)));
+        auto snd_result = tt::sync_wait(
+            ex::just(iterator(std::begin(c)), iterator(std::end(c)), init,
+                reduce_op, convert_op) |
+            hpx::transform_reduce(ex_policy.on(exec)));
 
         result_type r1 = hpx::get<0>(*snd_result);
 
@@ -71,14 +71,13 @@ void test_transform_reduce_sender(
         HPX_TEST_EQ(get<1>(r1), get<1>(r2));
     }
 
-
     {
         // edge case: empty range
 
-        auto snd_result =
-           tt::sync_wait(ex::just(iterator(std::begin(c)), iterator(std::begin(c)),
-                             init, reduce_op, convert_op) |
-               hpx::transform_reduce(ex_policy.on(exec)));
+        auto snd_result = tt::sync_wait(
+            ex::just(iterator(std::begin(c)), iterator(std::begin(c)), init,
+                reduce_op, convert_op) |
+            hpx::transform_reduce(ex_policy.on(exec)));
 
         result_type r1 = hpx::get<0>(*snd_result);