diff --git a/test_conformance/workgroups/test_wg_scan_reduce.cpp b/test_conformance/workgroups/test_wg_scan_reduce.cpp
index d7dd291499..9943ce03d8 100644
--- a/test_conformance/workgroups/test_wg_scan_reduce.cpp
+++ b/test_conformance/workgroups/test_wg_scan_reduce.cpp
@@ -22,8 +22,8 @@
 #include "testBase.h"
 
 cl_half_rounding_mode gHalfRoundingMode = CL_HALF_RTE;
-constexpr cl_half g_half_min = 0xfbff;
-constexpr cl_half g_half_max = 0x7bff;
+constexpr cl_half g_half_min = 0xFC00;
+constexpr cl_half g_half_max = 0x7C00;
 
 static std::string make_kernel_string(const std::string &type,
                                       const std::string &kernelName,
@@ -113,7 +113,7 @@ template <typename T> struct Max
     static constexpr const char *opName = "max";
     static constexpr T identityValue = std::is_integral_v<T>
         ? std::numeric_limits<T>::min()
-        : -std::numeric_limits<T>::max();
+        : -std::numeric_limits<T>::infinity();
     static T combine(T a, T b) { return std::max(a, b); }
 };
 
@@ -134,7 +134,9 @@ template <typename T> struct Min
 {
     using Type = T;
     static constexpr const char *opName = "min";
-    static constexpr T identityValue = std::numeric_limits<T>::max();
+    static constexpr T identityValue = std::is_integral_v<T>
+        ? std::numeric_limits<T>::max()
+        : std::numeric_limits<T>::infinity();
     static T combine(T a, T b) { return std::min(a, b); }
 };
 
@@ -434,6 +436,28 @@ template <typename C> struct ScanExclusive
     static constexpr const char *deviceTypeName =
         TestTypeInfo<Type>::deviceName;
     static constexpr const char *kernelName = "test_wg_scan_exclusive";
+
+    static int check_result(const Type &test_value, const Type &reference,
+                            const Type &max_err = 0)
+    {
+        if constexpr (std::is_floating_point_v<Type>)
+        {
+            if (std::abs(reference - test_value) > max_err) return -1;
+        }
+        else if constexpr (std::is_same_v<Type, cl_half>)
+        {
+            if (std::abs(cl_half_to_float(reference)
+                         - cl_half_to_float(test_value))
+                > cl_half_to_float(max_err))
+                return -1;
+        }
+        else
+        {
+            if (reference != test_value) return -1;
+        }
+        return CL_SUCCESS;
+    }
+
     static int verify(Type *inptr, Type *outptr, size_t n_elems,
                       size_t max_wg_size, const Type *const max_err = nullptr)
     {
@@ -444,7 +468,8 @@ template <typename C> struct ScanExclusive
             Type result = C::identityValue;
             for (size_t j = 0; j < wg_size; ++j)
             {
-                if (result != outptr[i + j])
+                if (check_result(outptr[i + j], result, max_err[j])
+                    != CL_SUCCESS)
                 {
                     log_info("%s_%s: Error at %zu\n", testName, testOpName,
                              i + j);
@@ -458,10 +483,79 @@ template <typename C> struct ScanExclusive
 
     static void generate_input_values(Type *inptr, size_t n_elems,
                                       size_t max_wg_size,
-                                      const Type *max_err = nullptr)
+                                      Type *const max_err = nullptr)
     {
         MTdataHolder d(gRandomSeed);
-        for (size_t i = 0; i < n_elems; i++) inptr[i] = (Type)genrand_int64(d);
+        if constexpr (std::is_floating_point_v<
+                          Type> || std::is_same_v<Type, cl_half>)
+        {
+            std::vector<Type> ref_vals(max_wg_size, 0);
+            if constexpr (std::is_same_v<Type, cl_half>)
+            {
+                // to prevent overflow limit range of randomization
+                float max_range = 99.0;
+                float min_range = -99.0;
+                // generate reference values for one work group
+                for (size_t j = 0; j < max_wg_size; j++)
+                    ref_vals[j] = cl_half_from_float(
+                        get_random_float(min_range, max_range, d),
+                        gHalfRoundingMode);
+
+                // populate reference data across all work groups
+                for (size_t i = 0; i < (size_t)n_elems; i += max_wg_size)
+                {
+                    size_t wg_size = std::min(max_wg_size, n_elems - i);
+                    memcpy(&inptr[i], ref_vals.data(), sizeof(Type) * wg_size);
+                }
+
+                if constexpr (std::is_same_v<Operation, Add<Type>>)
+                {
+                    // compute maximal summation error
+                    float s = std::abs(cl_half_to_float(ref_vals[0]));
+                    for (size_t i = 1; i < (size_t)n_elems; i++)
+                    {
+                        max_err[i] = cl_half_from_float(
+                            std::abs((max_wg_size - 1) * CL_HALF_EPSILON * s),
+                            gHalfRoundingMode);
+                        s += std::abs(cl_half_to_float(ref_vals[i]));
+                    }
+                }
+            }
+            else
+            {
+                double max_range = 999.0;
+                double min_range = -999.0;
+                for (size_t j = 0; j < max_wg_size; j++)
+                    ref_vals[j] = get_random_float(min_range, max_range, d);
+
+                for (size_t i = 0; i < (size_t)n_elems; i += max_wg_size)
+                {
+                    size_t work_group_size = std::min(max_wg_size, n_elems - i);
+                    memcpy(&inptr[i], ref_vals.data(),
+                           sizeof(Type) * work_group_size);
+                }
+
+                if constexpr (std::is_same_v<Operation, Add<Type>>)
+                {
+                    // compute maximal summation error
+                    Type s = std::abs(ref_vals[0]);
+                    for (size_t i = 1; i < (size_t)n_elems; i++)
+                    {
+                        max_err[i] = std::abs((max_wg_size - 1)
+                                              * (std::is_same_v<Type, cl_float>
+                                                     ? CL_FLT_EPSILON
+                                                     : CL_DBL_EPSILON)
+                                              * s);
+                        s += std::abs(ref_vals[i]);
+                    }
+                }
+            }
+        }
+        else
+        {
+            for (size_t i = 0; i < n_elems; i++)
+                inptr[i] = (Type)genrand_int64(d);
+        }
     }
 };
 
@@ -546,24 +640,23 @@ static int run_test(cl_device_id device, cl_context context,
     return TEST_PASS;
 }
 
-template <template <typename> class Op>
-static int run_scan_inclusive_all_types(cl_device_id device, cl_context context,
-                                        cl_command_queue queue,
-                                        int num_elements)
+template <template <typename> class Technique, template <typename> class Op>
+static int run_all_types(cl_device_id device, cl_context context,
+                         cl_command_queue queue, int num_elements)
 {
     int result = TEST_PASS;
 
-    result |= run_test<ScanInclusive<Op<cl_int>>>(device, context, queue,
-                                                  num_elements);
-    result |= run_test<ScanInclusive<Op<cl_uint>>>(device, context, queue,
-                                                   num_elements);
+    result |=
+        run_test<Technique<Op<cl_int>>>(device, context, queue, num_elements);
+    result |=
+        run_test<Technique<Op<cl_uint>>>(device, context, queue, num_elements);
 
     if (gHasLong)
     {
-        result |= run_test<ScanInclusive<Op<cl_long>>>(device, context, queue,
-                                                       num_elements);
-        result |= run_test<ScanInclusive<Op<cl_ulong>>>(device, context, queue,
-                                                        num_elements);
+        result |= run_test<Technique<Op<cl_long>>>(device, context, queue,
+                                                   num_elements);
+        result |= run_test<Technique<Op<cl_ulong>>>(device, context, queue,
+                                                    num_elements);
     }
 
     if (is_extension_available(device, "cl_khr_fp16"))
@@ -584,17 +677,17 @@ static int run_scan_inclusive_all_types(cl_device_id device, cl_context context,
             return TEST_FAIL;
         }
 
-        result |= run_test<ScanInclusive<Op<cl_half>>>(device, context, queue,
-                                                       num_elements);
+        result |= run_test<Technique<Op<cl_half>>>(device, context, queue,
+                                                   num_elements);
     }
 
-    result |= run_test<ScanInclusive<Op<cl_float>>>(device, context, queue,
-                                                    num_elements);
+    result |=
+        run_test<Technique<Op<cl_float>>>(device, context, queue, num_elements);
 
     if (is_extension_available(device, "cl_khr_fp64"))
     {
-        result |= run_test<ScanInclusive<Op<cl_double>>>(device, context, queue,
-                                                         num_elements);
+        result |= run_test<Technique<Op<cl_double>>>(device, context, queue,
+                                                     num_elements);
     }
 
     return result;
@@ -602,231 +695,51 @@ static int run_scan_inclusive_all_types(cl_device_id device, cl_context context,
 
 REGISTER_TEST_VERSION(work_group_reduce_add, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |=
-        run_test<Reduce<Add<cl_int>>>(device, context, queue, num_elements);
-    result |=
-        run_test<Reduce<Add<cl_uint>>>(device, context, queue, num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<Reduce<Add<cl_long>>>(device, context, queue,
-                                                 num_elements);
-        result |= run_test<Reduce<Add<cl_ulong>>>(device, context, queue,
-                                                  num_elements);
-    }
-
-    if (is_extension_available(device, "cl_khr_fp16"))
-    {
-        const cl_device_fp_config fpConfigHalf =
-            get_default_rounding_mode(device, CL_DEVICE_HALF_FP_CONFIG);
-        if ((fpConfigHalf & CL_FP_ROUND_TO_NEAREST) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTE;
-        }
-        else if ((fpConfigHalf & CL_FP_ROUND_TO_ZERO) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTZ;
-        }
-        else
-        {
-            log_error("Error while acquiring half rounding mode\n");
-            return TEST_FAIL;
-        }
-
-        result |= run_test<Reduce<Add<cl_half>>>(device, context, queue,
-                                                 num_elements);
-    }
-
-    result |=
-        run_test<Reduce<Add<cl_float>>>(device, context, queue, num_elements);
-
-    if (is_extension_available(device, "cl_khr_fp64"))
-    {
-        result |= run_test<Reduce<Add<cl_double>>>(device, context, queue,
-                                                   num_elements);
-    }
-
-    return result;
+    return run_all_types<Reduce, Add>(device, context, queue, num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_reduce_max, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |=
-        run_test<Reduce<Max<cl_int>>>(device, context, queue, num_elements);
-    result |=
-        run_test<Reduce<Max<cl_uint>>>(device, context, queue, num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<Reduce<Max<cl_long>>>(device, context, queue,
-                                                 num_elements);
-        result |= run_test<Reduce<Max<cl_ulong>>>(device, context, queue,
-                                                  num_elements);
-    }
-
-    if (is_extension_available(device, "cl_khr_fp16"))
-    {
-        const cl_device_fp_config fpConfigHalf =
-            get_default_rounding_mode(device, CL_DEVICE_HALF_FP_CONFIG);
-        if ((fpConfigHalf & CL_FP_ROUND_TO_NEAREST) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTE;
-        }
-        else if ((fpConfigHalf & CL_FP_ROUND_TO_ZERO) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTZ;
-        }
-        else
-        {
-            log_error("Error while acquiring half rounding mode\n");
-            return TEST_FAIL;
-        }
-
-        result |= run_test<Reduce<Max<cl_half>>>(device, context, queue,
-                                                 num_elements);
-    }
-
-    result |=
-        run_test<Reduce<Max<cl_float>>>(device, context, queue, num_elements);
-
-    if (is_extension_available(device, "cl_khr_fp64"))
-    {
-        result |= run_test<Reduce<Max<cl_double>>>(device, context, queue,
-                                                   num_elements);
-    }
-
-    return result;
+    return run_all_types<Reduce, Max>(device, context, queue, num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_reduce_min, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |=
-        run_test<Reduce<Min<cl_int>>>(device, context, queue, num_elements);
-    result |=
-        run_test<Reduce<Min<cl_uint>>>(device, context, queue, num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<Reduce<Min<cl_long>>>(device, context, queue,
-                                                 num_elements);
-        result |= run_test<Reduce<Min<cl_ulong>>>(device, context, queue,
-                                                  num_elements);
-    }
-
-    if (is_extension_available(device, "cl_khr_fp16"))
-    {
-        const cl_device_fp_config fpConfigHalf =
-            get_default_rounding_mode(device, CL_DEVICE_HALF_FP_CONFIG);
-        if ((fpConfigHalf & CL_FP_ROUND_TO_NEAREST) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTE;
-        }
-        else if ((fpConfigHalf & CL_FP_ROUND_TO_ZERO) != 0)
-        {
-            gHalfRoundingMode = CL_HALF_RTZ;
-        }
-        else
-        {
-            log_error("Error while acquiring half rounding mode\n");
-            return TEST_FAIL;
-        }
-
-        result |= run_test<Reduce<Min<cl_half>>>(device, context, queue,
-                                                 num_elements);
-    }
-
-    result |=
-        run_test<Reduce<Min<cl_float>>>(device, context, queue, num_elements);
-
-    if (is_extension_available(device, "cl_khr_fp64"))
-    {
-        result |= run_test<Reduce<Min<cl_double>>>(device, context, queue,
-                                                   num_elements);
-    }
-
-    return result;
+    return run_all_types<Reduce, Min>(device, context, queue, num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_inclusive_add, Version(2, 0))
 {
-    return run_scan_inclusive_all_types<Add>(device, context, queue,
+    return run_all_types<ScanInclusive, Add>(device, context, queue,
                                              num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_inclusive_max, Version(2, 0))
 {
-    return run_scan_inclusive_all_types<Max>(device, context, queue,
+    return run_all_types<ScanInclusive, Max>(device, context, queue,
                                              num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_inclusive_min, Version(2, 0))
 {
-    return run_scan_inclusive_all_types<Min>(device, context, queue,
+    return run_all_types<ScanInclusive, Min>(device, context, queue,
                                              num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_exclusive_add, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |= run_test<ScanExclusive<Add<cl_int>>>(device, context, queue,
-                                                   num_elements);
-    result |= run_test<ScanExclusive<Add<cl_uint>>>(device, context, queue,
-                                                    num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<ScanExclusive<Add<cl_long>>>(device, context, queue,
-                                                        num_elements);
-        result |= run_test<ScanExclusive<Add<cl_ulong>>>(device, context, queue,
-                                                         num_elements);
-    }
-
-    return result;
+    return run_all_types<ScanExclusive, Add>(device, context, queue,
+                                             num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_exclusive_max, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |= run_test<ScanExclusive<Max<cl_int>>>(device, context, queue,
-                                                   num_elements);
-    result |= run_test<ScanExclusive<Max<cl_uint>>>(device, context, queue,
-                                                    num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<ScanExclusive<Max<cl_long>>>(device, context, queue,
-                                                        num_elements);
-        result |= run_test<ScanExclusive<Max<cl_ulong>>>(device, context, queue,
-                                                         num_elements);
-    }
-
-    return result;
+    return run_all_types<ScanExclusive, Max>(device, context, queue,
+                                             num_elements);
 }
 
 REGISTER_TEST_VERSION(work_group_scan_exclusive_min, Version(2, 0))
 {
-    int result = TEST_PASS;
-
-    result |= run_test<ScanExclusive<Min<cl_int>>>(device, context, queue,
-                                                   num_elements);
-    result |= run_test<ScanExclusive<Min<cl_uint>>>(device, context, queue,
-                                                    num_elements);
-
-    if (gHasLong)
-    {
-        result |= run_test<ScanExclusive<Min<cl_long>>>(device, context, queue,
-                                                        num_elements);
-        result |= run_test<ScanExclusive<Min<cl_ulong>>>(device, context, queue,
-                                                         num_elements);
-    }
-
-    return result;
+    return run_all_types<ScanExclusive, Min>(device, context, queue,
+                                             num_elements);
 }