Fix double dereference bug in minmax dispatches and standardize test code

Author: dasaneek007-cpu

libs/core/algorithms/include/hpx/parallel/algorithms/minmax.hpp

@@ -407,7 +407,8 @@ namespace hpx::parallel {
             auto smallest = it;
 
             using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
+                std::decay_t<hpx::util::invoke_result_t<Proj,
+                    hpx::traits::iter_reference_t<FwdIter>>>>;
 
             element_type value = HPX_INVOKE(proj, *smallest);
             util::loop_n<std::decay_t<ExPolicy>>(
@@ -444,7 +445,9 @@ namespace hpx::parallel {
                 auto smallest = *it;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<typename std::
+                                iterator_traits<FwdIter>::value_type>>>>;
 
                 element_type value = HPX_INVOKE(proj, *smallest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -476,7 +479,8 @@ namespace hpx::parallel {
                 auto smallest = first;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *smallest))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<FwdIter>>>>;
 
                 element_type value = HPX_INVOKE(proj, *smallest);
                 util::loop(HPX_FORWARD(ExPolicy, policy), ++first, last,
@@ -559,7 +563,8 @@ namespace hpx::parallel {
             auto largest = it;
 
             using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
+                std::decay_t<hpx::util::invoke_result_t<Proj,
+                    hpx::traits::iter_reference_t<FwdIter>>>>;
 
             element_type value = HPX_INVOKE(proj, *largest);
             util::loop_n<std::decay_t<ExPolicy>>(
@@ -596,7 +601,9 @@ namespace hpx::parallel {
                 auto largest = *it;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<typename std::
+                                iterator_traits<FwdIter>::value_type>>>>;
 
                 element_type value = HPX_INVOKE(proj, *largest);
                 util::loop_n<std::decay_t<ExPolicy>>(
@@ -628,7 +635,8 @@ namespace hpx::parallel {
                 auto largest = first;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *largest))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<FwdIter>>>>;
 
                 element_type value = HPX_INVOKE(proj, *largest);
                 util::loop(HPX_FORWARD(ExPolicy, policy), ++first, last,
@@ -711,7 +719,8 @@ namespace hpx::parallel {
                 return result;
 
             using element_type = hpx::traits::proxy_value_t<
-                std::decay_t<decltype(HPX_INVOKE(proj, *it))>>;
+                std::decay_t<hpx::util::invoke_result_t<Proj,
+                    hpx::traits::iter_reference_t<FwdIter>>>>;
 
             element_type min_value = HPX_INVOKE(proj, *it);
             element_type max_value = min_value;
@@ -755,7 +764,8 @@ namespace hpx::parallel {
                 auto result = *it;
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *result.min))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<Iter>>>>;
 
                 element_type min_value = HPX_INVOKE(proj, *result.min);
                 element_type max_value = HPX_INVOKE(proj, *result.max);
@@ -801,7 +811,8 @@ namespace hpx::parallel {
                 }
 
                 using element_type = hpx::traits::proxy_value_t<
-                    std::decay_t<decltype(HPX_INVOKE(proj, *min))>>;
+                    std::decay_t<hpx::util::invoke_result_t<Proj,
+                        hpx::traits::iter_reference_t<FwdIter>>>>;
 
                 element_type min_value = HPX_INVOKE(proj, *min);
                 element_type max_value = HPX_INVOKE(proj, *max);

libs/core/algorithms/tests/unit/algorithms/minmax_element_projection.cpp

@@ -17,7 +17,7 @@
 void test_min_element_projection()
 {
     using namespace hpx::execution;
-    typedef std::pair<int, int> element;
+    using element = std::pair<int, int>;
     std::vector<element> c = {{1, 10}, {2, 5}, {3, 15}};
 
     auto proj = [](element const& p) { return p.second; };
@@ -38,7 +38,7 @@ void test_min_element_projection()
 void test_max_element_projection()
 {
     using namespace hpx::execution;
-    typedef std::pair<int, int> element;
+    using element = std::pair<int, int>;
     std::vector<element> c = {{1, 10}, {2, 5}, {3, 15}};
 
     auto proj = [](element const& p) { return p.second; };
@@ -59,7 +59,7 @@ void test_max_element_projection()
 void test_minmax_element_projection()
 {
     using namespace hpx::execution;
-    typedef std::pair<int, int> element;
+    using element = std::pair<int, int>;
     std::vector<element> c = {{1, 10}, {2, 5}, {3, 15}};
 
     auto proj = [](element const& p) { return p.second; };