diff --git a/test_conformance/conversions/basic_test_conversions.cpp b/test_conformance/conversions/basic_test_conversions.cpp
index aa4409eb2..dff9788c7 100644
--- a/test_conformance/conversions/basic_test_conversions.cpp
+++ b/test_conformance/conversions/basic_test_conversions.cpp
@@ -17,10 +17,6 @@
 #include "harness/compat.h"
 #include "harness/rounding_mode.h"
 #include "harness/ThreadPool.h"
-#include "harness/testHarness.h"
-#include "harness/kernelHelpers.h"
-#include "harness/mt19937.h"
-#include "harness/kernelHelpers.h"
 
 #if defined(__APPLE__)
 #include <sys/sysctl.h>
@@ -43,8 +39,6 @@
 
 #include <sstream>
 #include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
 #if !defined(_WIN32)
 #include <libgen.h>
 #include <sys/mman.h>
@@ -58,11 +52,6 @@
 
 #include "basic_test_conversions.h"
 
-#if (defined(_WIN32) && defined(_MSC_VER))
-// need for _controlfp_s and rouinding modes in RoundingMode
-#include "harness/testHarness.h"
-#endif
-
 #if defined(_WIN32)
 #include <mmintrin.h>
 #include <emmintrin.h>
@@ -113,16 +102,11 @@ MTdata gMTdata;
 const char **argList = NULL;
 int argCount = 0;
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 double SubtractTime(uint64_t endTime, uint64_t startTime);
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 cl_half_rounding_mode DataInitInfo::halfRoundingMode = CL_HALF_RTE;
 cl_half_rounding_mode ConversionsTest::defaultHalfRoundingMode = CL_HALF_RTE;
 
-////////////////////////////////////////////////////////////////////////////////////////
 // clang-format off
 // for readability sake keep this section unformatted
 
@@ -279,7 +263,6 @@ std::vector<double> DataInitInfo::specialValuesDouble = {
     MAKE_HEX_DOUBLE(0x1.ffffffff00001p62, 0x1ffffffff00001LL, 10),
 };
 // clang-format on
-////////////////////////////////////////////////////////////////////////////////////////
 
 // Windows (since long double got deprecated) sets the x87 to 53-bit precision
 // (that's x87 default state).  This causes problems with the tests that
@@ -304,8 +287,6 @@ static inline void Force64BitFPUPrecision(void)
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 int CalcRefValsPat<InType, OutType, InFP, OutFP>::check_result(void *test,
                                                                uint32_t count,
@@ -370,8 +351,6 @@ int CalcRefValsPat<InType, OutType, InFP, OutFP>::check_result(void *test,
     return 0;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 cl_uint RoundUpToNextPowerOfTwo(cl_uint x)
 {
     if (0 == (x & (x - 1))) return x;
@@ -381,8 +360,6 @@ cl_uint RoundUpToNextPowerOfTwo(cl_uint x)
     return x + x;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 cl_int CustomConversionsTest::Run()
 {
     int startMinVectorSize = gMinVectorSize;
@@ -447,7 +424,8 @@ cl_int CustomConversionsTest::Run()
                 gMinVectorSize = 0;
         }
 
-        IterOverSelectedTypes iter(typeIterator, *this, inType, outType);
+        IterOverSelectedTypes iter(typeIterator, *this, inType, outType, round,
+                                   sat);
 
         iter.Run();
 
@@ -462,8 +440,6 @@ cl_int CustomConversionsTest::Run()
     return gFailCount;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 ConversionsTest::ConversionsTest(cl_device_id device, cl_context context,
                                  cl_command_queue queue)
     : context(context), device(device), queue(queue), num_elements(0),
@@ -472,8 +448,6 @@ ConversionsTest::ConversionsTest(cl_device_id device, cl_context context,
                      cl_double(0), cl_ulong(0), cl_long(0) })
 {}
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 cl_int ConversionsTest::Run()
 {
     IterOverTypes iter(typeIterator, *this);
@@ -483,8 +457,6 @@ cl_int ConversionsTest::Run()
     return gFailCount;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 cl_int ConversionsTest::SetUp(int elements)
 {
     num_elements = elements;
@@ -512,16 +484,14 @@ cl_int ConversionsTest::SetUp(int elements)
     return CL_SUCCESS;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 void ConversionsTest::TestTypesConversion(const Type &inType,
-                                          const Type &outType, int &testNumber)
+                                          const Type &outType, int &testNumber,
+                                          int startMinVectorSize)
 {
     SaturationMode sat;
     RoundingMode round;
     int error;
-    int startMinVectorSize = gMinVectorSize;
 
     // skip longs on embedded
     if (!gHasLong
@@ -609,8 +579,6 @@ void ConversionsTest::TestTypesConversion(const Type &inType,
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 int ConversionsTest::DoTest(Type outType, Type inType, SaturationMode sat,
                             RoundingMode round)
@@ -619,12 +587,8 @@ int ConversionsTest::DoTest(Type outType, Type inType, SaturationMode sat,
     cl_ulong wall_start = mach_absolute_time();
 #endif
 
-#if 0
     uint64_t lastCase = 1ULL << (8 * gTypeSizes[inType]);
-#else
     cl_uint threads = GetThreadCount();
-    uint64_t lastCase = 1000000ULL;
-#endif
 
     DataInitInfo info = { 0, 0, outType, inType, sat, round, threads };
     DataInfoSpec<InType, OutType, InFP, OutFP> init_info(info);
@@ -689,11 +653,9 @@ int ConversionsTest::DoTest(Type outType, Type inType, SaturationMode sat,
             init_info.round = round = kRoundTowardZero;
     }
 
-#if 0
     // Figure out how many elements are in a work block
     // we handle 64-bit types a bit differently.
     if (8 * gTypeSizes[inType] > 32) lastCase = 0x100000000ULL;
-#endif
 
     if (!gWimpyMode && gIsEmbedded)
         step = blockCount * EMBEDDED_REDUCTION_FACTOR;
@@ -996,8 +958,6 @@ double SubtractTime(uint64_t endTime, uint64_t startTime)
 }
 #endif
 
-////////////////////////////////////////////////////////////////////////////////
-
 static void setAllowZ(uint8_t *allow, uint32_t *x, cl_uint count)
 {
     cl_uint i;
@@ -1005,7 +965,6 @@ static void setAllowZ(uint8_t *allow, uint32_t *x, cl_uint count)
         allow[i] |= (uint8_t)((x[i] & 0x7f800000U) == 0);
 }
 
-
 void MapResultValuesComplete(const std::unique_ptr<CalcRefValsBase> &ptr);
 
 void CL_CALLBACK CalcReferenceValuesComplete(cl_event e, cl_int status,
@@ -1046,7 +1005,6 @@ void MapResultValuesComplete(const std::unique_ptr<CalcRefValsBase> &info)
     // destroyed automatically soon after we exit.
 }
 
-
 void CL_CALLBACK CalcReferenceValuesComplete(cl_event e, cl_int status,
                                              void *data)
 {
@@ -1172,12 +1130,8 @@ void CL_CALLBACK CalcReferenceValuesComplete(cl_event e, cl_int status,
     // CalcReferenceValuesComplete exit.
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-
 namespace conv_test {
 
-////////////////////////////////////////////////////////////////////////////////
-
 cl_int InitData(cl_uint job_id, cl_uint thread_id, void *p)
 {
     DataInitBase *info = (DataInitBase *)p;
@@ -1187,8 +1141,6 @@ cl_int InitData(cl_uint job_id, cl_uint thread_id, void *p)
     return CL_SUCCESS;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 cl_int PrepareReference(cl_uint job_id, cl_uint thread_id, void *p)
 {
     DataInitBase *info = (DataInitBase *)p;
@@ -1205,7 +1157,6 @@ cl_int PrepareReference(cl_uint job_id, cl_uint thread_id, void *p)
     void *a = (cl_uchar *)gAllowZ + job_id * count;
     void *d = (cl_uchar *)gRef + job_id * count * gTypeSizes[info->outType];
 
-
     if (outType != inType)
     {
         // create the reference while we wait
@@ -1344,8 +1295,6 @@ cl_int PrepareReference(cl_uint job_id, cl_uint thread_id, void *p)
     return CL_SUCCESS;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 uint64_t GetTime(void)
 {
 #if defined(__APPLE__)
@@ -1360,8 +1309,6 @@ uint64_t GetTime(void)
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Note: not called reentrantly
 void WriteInputBufferComplete(void *data)
 {
@@ -1422,8 +1369,6 @@ void WriteInputBufferComplete(void *data)
     // automatically soon after we exit.
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 cl_program MakeProgram(Type outType, Type inType, SaturationMode sat,
                        RoundingMode round, int vectorSize, cl_kernel *outKernel)
 {
@@ -1554,8 +1499,6 @@ cl_program MakeProgram(Type outType, Type inType, SaturationMode sat,
     return program;
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-
 int RunKernel(cl_kernel kernel, void *inBuf, void *outBuf, size_t blockCount)
 {
     // The global dimensions are just the blockCount to execute since we haven't
@@ -1581,8 +1524,6 @@ int RunKernel(cl_kernel kernel, void *inBuf, void *outBuf, size_t blockCount)
     return 0;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 int GetTestCase(const char *name, Type *outType, Type *inType,
                 SaturationMode *sat, RoundingMode *round)
 {
@@ -1639,6 +1580,3 @@ int GetTestCase(const char *name, Type *outType, Type *inType,
 }
 
 } // namespace conv_test
-
-
-////////////////////////////////////////////////////////////////////////////////////////
diff --git a/test_conformance/conversions/basic_test_conversions.h b/test_conformance/conversions/basic_test_conversions.h
index 8ee5bb259..260328d69 100644
--- a/test_conformance/conversions/basic_test_conversions.h
+++ b/test_conformance/conversions/basic_test_conversions.h
@@ -42,8 +42,6 @@
 
 #include "conversions_data_info.h"
 
-// typedef void (*Convert)( void *dest, void *src, size_t );
-
 #define kVectorSizeCount 6
 #define kMaxVectorSize 16
 #define kPageSize 4096
@@ -52,11 +50,6 @@
 #define EMBEDDED_REDUCTION_FACTOR 16
 #define PERF_LOOP_COUNT 100
 
-
-// extern Convert gConversions[kTypeCount][kTypeCount];                // [dest
-// format][source format] extern Convert
-// gSaturatedConversions[kTypeCount][kTypeCount];       // [dest format][source
-// format]
 extern const char *gTypeNames[ kTypeCount ];
 extern const char *gRoundingModeNames[ kRoundingModeCount ];        // { "", "_rte", "_rtp", "_rtn", "_rtz" }
 extern const char *gSaturationNames[ kSaturationModeCount ];        // { "", "_sat" }
@@ -114,8 +107,6 @@ extern int vectorSizes[];
 extern size_t gComputeDevices;
 extern uint32_t gDeviceFrequency;
 
-//--------------------------------------------------------------------------
-
 namespace conv_test {
 
 cl_program MakeProgram(Type outType, Type inType, SaturationMode sat,
@@ -136,10 +127,9 @@ void *FlushToZero(void);
 void UnFlushToZero(void *);
 }
 
-//--------------------------------------------------------------------------
-
 struct CalcRefValsBase
 {
+    virtual ~CalcRefValsBase() = default;
     virtual int check_result(void *, uint32_t, int) { return 0; }
 
     // pointer back to the parent WriteInputBufferInfo struct
@@ -151,16 +141,12 @@ struct CalcRefValsBase
     cl_int result;
 };
 
-//--------------------------------------------------------------------------
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 struct CalcRefValsPat : CalcRefValsBase
 {
     int check_result(void *, uint32_t, int) override;
 };
 
-//--------------------------------------------------------------------------
-
 struct WriteInputBufferInfo
 {
     WriteInputBufferInfo()
@@ -181,9 +167,6 @@ struct WriteInputBufferInfo
     std::vector<std::unique_ptr<CalcRefValsBase>> calcInfo;
 };
 
-
-//--------------------------------------------------------------------------
-
 // Must be aligned with Type enums!
 using TypeIter =
     std::tuple<cl_uchar, cl_char, cl_ushort, cl_short, cl_uint, cl_int, cl_half,
@@ -192,26 +175,27 @@ using TypeIter =
 // hardcoded solution needed due to typeid confusing cl_ushort/cl_half
 constexpr bool isTypeFp[] = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0 };
 
-//--------------------------------------------------------------------------
-
 // Helper test fixture for constructing OpenCL objects used in testing
 // a variety of simple command-buffer enqueue scenarios.
 struct ConversionsTest
 {
+    virtual ~ConversionsTest() = default;
+
     ConversionsTest(cl_device_id device, cl_context context,
                     cl_command_queue queue);
 
-    virtual cl_int SetUp(int elements);
+    cl_int SetUp(int elements);
 
     // Test body returning an OpenCL error code
-    virtual cl_int Run();
+    cl_int Run();
 
     template <typename InType, typename OutType, bool InFP, bool OutFP>
     int DoTest(Type outType, Type inType, SaturationMode sat,
                RoundingMode round);
 
     template <typename InType, typename OutType, bool InFP, bool OutFP>
-    void TestTypesConversion(const Type &inType, const Type &outType, int &tn);
+    void TestTypesConversion(const Type &inType, const Type &outType, int &tn,
+                             int startMinVectorSize);
 
 protected:
     cl_context context;
@@ -226,8 +210,6 @@ struct ConversionsTest
     static cl_half_rounding_mode defaultHalfRoundingMode;
 };
 
-//--------------------------------------------------------------------------
-
 struct CustomConversionsTest : ConversionsTest
 {
     CustomConversionsTest(cl_device_id device, cl_context context,
@@ -235,16 +217,14 @@ struct CustomConversionsTest : ConversionsTest
         : ConversionsTest(device, context, queue)
     {}
 
-    cl_int Run() override;
+    cl_int Run();
 };
 
-//--------------------------------------------------------------------------
-
 template <class T>
 int MakeAndRunTest(cl_device_id device, cl_context context,
                    cl_command_queue queue, int num_elements)
 {
-    auto test_fixture = T(device, context, queue);
+    T test_fixture(device, context, queue);
 
     cl_int error = test_fixture.SetUp(num_elements);
     test_error_ret(error, "Error in test initialization", TEST_FAIL);
@@ -252,8 +232,6 @@ int MakeAndRunTest(cl_device_id device, cl_context context,
     return test_fixture.Run();
 }
 
-//--------------------------------------------------------------------------
-
 struct TestType
 {
     template <typename T> bool testType(Type in)
@@ -276,19 +254,17 @@ struct TestType
     }
 };
 
-//--------------------------------------------------------------------------
 // Helper structures to iterate over all tuple attributes of different types
 struct IterOverTypes : public TestType
 {
     IterOverTypes(const TypeIter &typeIter, ConversionsTest &test)
         : inType((Type)0), outType((Type)0), typeIter(typeIter), test(test),
-          testNumber(-1)
+          testNumber(-1), startMinVectorSize(gMinVectorSize)
     {}
 
     void Run() { for_each_out_elem(typeIter); }
 
 protected:
-    ////////////////////////////////////////////////////////////////////////////////////////
 
     template <std::size_t Out = 0, typename OutType>
     void iterate_out_type(const OutType &t)
@@ -298,8 +274,6 @@ struct IterOverTypes : public TestType
         inType = (Type)0;
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In, std::size_t Out, typename OutType,
               typename InType>
     void iterate_in_type(const InType &t)
@@ -310,20 +284,16 @@ struct IterOverTypes : public TestType
 
         // run the conversions
         test.TestTypesConversion<InType, OutType, isTypeFp[In], isTypeFp[Out]>(
-            inType, outType, testNumber);
+            inType, outType, testNumber, startMinVectorSize);
         inType = (Type)(inType + 1);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t Out = 0, typename... Tp>
     inline typename std::enable_if<Out == sizeof...(Tp), void>::type
     for_each_out_elem(
         const std::tuple<Tp...> &) // Unused arguments are given no names.
     {}
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t Out = 0, typename... Tp>
         inline typename std::enable_if < Out<sizeof...(Tp), void>::type
         for_each_out_elem(const std::tuple<Tp...> &t)
@@ -332,8 +302,6 @@ struct IterOverTypes : public TestType
         for_each_out_elem<Out + 1, Tp...>(t);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In = 0, std::size_t Out, typename OutType,
               typename... Tp>
     inline typename std::enable_if<In == sizeof...(Tp), void>::type
@@ -341,8 +309,6 @@ struct IterOverTypes : public TestType
         const std::tuple<Tp...> &) // Unused arguments are given no names.
     {}
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In = 0, std::size_t Out, typename OutType,
               typename... Tp>
         inline typename std::enable_if < In<sizeof...(Tp), void>::type
@@ -352,30 +318,30 @@ struct IterOverTypes : public TestType
         for_each_in_elem<In + 1, Out, OutType, Tp...>(t);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
 protected:
     Type inType;
     Type outType;
     const TypeIter &typeIter;
     ConversionsTest &test;
     int testNumber;
+    int startMinVectorSize;
 };
 
-//--------------------------------------------------------------------------
+
 // Helper structures to select type 2 type conversion test case
 struct IterOverSelectedTypes : public TestType
 {
     IterOverSelectedTypes(const TypeIter &typeIter, ConversionsTest &test,
-                          const Type &in, const Type &out)
-        : inType(in), outType(out), typeIter(typeIter), test(test),
-          testNumber(-1)
+                          const Type in, const Type out,
+                          const RoundingMode round, const SaturationMode sat)
+        : inType(in), outType(out), rounding(round), saturation(sat),
+          typeIter(typeIter), test(test), testNumber(-1),
+          startMinVectorSize(gMinVectorSize)
     {}
 
     void Run() { for_each_out_elem(typeIter); }
 
 protected:
-    ////////////////////////////////////////////////////////////////////////////////////////
 
     template <std::size_t Out = 0, typename OutType>
     void iterate_out_type(const OutType &t)
@@ -383,30 +349,24 @@ struct IterOverSelectedTypes : public TestType
         for_each_in_elem<0, Out, OutType>(typeIter);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In, std::size_t Out, typename OutType,
               typename InType>
     void iterate_in_type(const InType &t)
     {
         if (testType<InType>(inType) && testType<OutType>(outType))
         {
-            // run the conversions
-            test.TestTypesConversion<InType, OutType, isTypeFp[In],
-                                     isTypeFp[Out]>(inType, outType,
-                                                    testNumber);
+            // run selected conversion
+            // testing of the result will happen afterwards
+            test.DoTest<InType, OutType, isTypeFp[In], isTypeFp[Out]>(
+                outType, inType, saturation, rounding);
         }
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t Out = 0, typename... Tp>
     inline typename std::enable_if<Out == sizeof...(Tp), void>::type
     for_each_out_elem(const std::tuple<Tp...> &)
     {}
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t Out = 0, typename... Tp>
         inline typename std::enable_if < Out<sizeof...(Tp), void>::type
         for_each_out_elem(const std::tuple<Tp...> &t)
@@ -415,16 +375,12 @@ struct IterOverSelectedTypes : public TestType
         for_each_out_elem<Out + 1, Tp...>(t);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In = 0, std::size_t Out, typename OutType,
               typename... Tp>
     inline typename std::enable_if<In == sizeof...(Tp), void>::type
     for_each_in_elem(const std::tuple<Tp...> &)
     {}
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
     template <std::size_t In = 0, std::size_t Out, typename OutType,
               typename... Tp>
         inline typename std::enable_if < In<sizeof...(Tp), void>::type
@@ -434,17 +390,18 @@ struct IterOverSelectedTypes : public TestType
         for_each_in_elem<In + 1, Out, OutType, Tp...>(t);
     }
 
-    ////////////////////////////////////////////////////////////////////////////////////////
-
 protected:
     Type inType;
     Type outType;
+    RoundingMode rounding;
+    SaturationMode saturation;
+
     const TypeIter &typeIter;
     ConversionsTest &test;
     int testNumber;
+    int startMinVectorSize;
 };
 
-//--------------------------------------------------------------------------
 
 #endif /* BASIC_TEST_CONVERSIONS_H */
 
diff --git a/test_conformance/conversions/conversions_data_info.h b/test_conformance/conversions/conversions_data_info.h
index 6f81224bb..837b16772 100644
--- a/test_conformance/conversions/conversions_data_info.h
+++ b/test_conformance/conversions/conversions_data_info.h
@@ -44,7 +44,6 @@ extern roundingMode qcom_rm;
 extern size_t gTypeSizes[kTypeCount];
 extern void *gIn;
 
-//--------------------------------------------------------------------------
 
 typedef enum
 {
@@ -54,7 +53,6 @@ typedef enum
     kSaturationModeCount
 } SaturationMode;
 
-//--------------------------------------------------------------------------
 
 struct DataInitInfo
 {
@@ -73,28 +71,26 @@ struct DataInitInfo
     static std::vector<double> specialValuesDouble;
 };
 
-//--------------------------------------------------------------------------
 
 #define HFF(num) cl_half_from_float(num, DataInitInfo::halfRoundingMode)
 #define HTF(num) cl_half_to_float(num)
 
-//--------------------------------------------------------------------------
 
 struct DataInitBase : public DataInitInfo
 {
-    DataInitBase(const DataInitInfo &agg): DataInitInfo(agg) {}
+    virtual ~DataInitBase() = default;
+
+    explicit DataInitBase(const DataInitInfo &agg): DataInitInfo(agg) {}
     virtual void conv_array(void *out, void *in, size_t n) {}
     virtual void conv_array_sat(void *out, void *in, size_t n) {}
     virtual void init(const cl_uint &, const cl_uint &) {}
 };
 
-//--------------------------------------------------------------------------
 
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 struct DataInfoSpec : public DataInitBase
 {
-
-    DataInfoSpec(const DataInitInfo &agg);
+    explicit DataInfoSpec(const DataInitInfo &agg);
 
     // helpers
     float round_to_int(float f);
@@ -114,42 +110,38 @@ struct DataInfoSpec : public DataInitBase
 
     std::vector<MTdataHolder> mdv;
 
-    ////////////////////////////////////////////////////////////////////////////
+
     constexpr bool is_in_half() const
     {
         return (std::is_same<InType, cl_half>::value && InFP);
     }
 
-    ////////////////////////////////////////////////////////////////////////////
     constexpr bool is_out_half() const
     {
         return (std::is_same<OutType, cl_half>::value && OutFP);
     }
 
-    ////////////////////////////////////////////////////////////////////////////
     void conv_array(void *out, void *in, size_t n) override
     {
         for (size_t i = 0; i < n; i++)
             conv(&((OutType *)out)[i], &((InType *)in)[i]);
     }
 
-    ////////////////////////////////////////////////////////////////////////////
     void conv_array_sat(void *out, void *in, size_t n) override
     {
         for (size_t i = 0; i < n; i++)
             conv_sat(&((OutType *)out)[i], &((InType *)in)[i]);
     }
 
-    ////////////////////////////////////////////////////////////////////////////
     void init(const cl_uint &, const cl_uint &) override;
     InType clamp(const InType &);
-    ////////////////////////////////////////////////////////////////////////////
+
     inline float fclamp(float lo, float v, float hi)
     {
         v = v < lo ? lo : v;
         return v < hi ? v : hi;
     }
-    ////////////////////////////////////////////////////////////////////////////
+
     inline double dclamp(double lo, double v, double hi)
     {
         v = v < lo ? lo : v;
@@ -157,8 +149,6 @@ struct DataInfoSpec : public DataInitBase
     }
 };
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 DataInfoSpec<InType, OutType, InFP, OutFP>::DataInfoSpec(
     const DataInitInfo &agg)
@@ -287,8 +277,6 @@ DataInfoSpec<InType, OutType, InFP, OutFP>::DataInfoSpec(
     // clang-format on
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 float DataInfoSpec<InType, OutType, InFP, OutFP>::round_to_int(float f)
 {
@@ -318,8 +306,6 @@ float DataInfoSpec<InType, OutType, InFP, OutFP>::round_to_int(float f)
     return f;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 long long
 DataInfoSpec<InType, OutType, InFP, OutFP>::round_to_int_and_clamp(double f)
@@ -353,8 +339,6 @@ DataInfoSpec<InType, OutType, InFP, OutFP>::round_to_int_and_clamp(double f)
     return (long long)f;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 OutType DataInfoSpec<InType, OutType, InFP, OutFP>::absolute(const OutType &x)
 {
@@ -373,15 +357,11 @@ OutType DataInfoSpec<InType, OutType, InFP, OutFP>::absolute(const OutType &x)
     return u.f;
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename T, bool fp> constexpr bool is_half()
 {
     return (std::is_same<cl_half, T>::value && fp);
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 void DataInfoSpec<InType, OutType, InFP, OutFP>::conv(OutType *out, InType *in)
 {
@@ -541,13 +521,9 @@ void DataInfoSpec<InType, OutType, InFP, OutFP>::conv(OutType *out, InType *in)
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 #define CLAMP(_lo, _x, _hi)                                                    \
     ((_x) < (_lo) ? (_lo) : ((_x) > (_hi) ? (_hi) : (_x)))
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 void DataInfoSpec<InType, OutType, InFP, OutFP>::conv_sat(OutType *out,
                                                           InType *in)
@@ -681,8 +657,6 @@ void DataInfoSpec<InType, OutType, InFP, OutFP>::conv_sat(OutType *out,
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 void DataInfoSpec<InType, OutType, InFP, OutFP>::init(const cl_uint &job_id,
                                                       const cl_uint &thread_id)
@@ -692,9 +666,6 @@ void DataInfoSpec<InType, OutType, InFP, OutFP>::init(const cl_uint &job_id,
 
     if (is_in_half())
     {
-        const unsigned m_size = 0x1ff;
-        const unsigned e_size = 0xf;
-        const unsigned s_size = 0x2;
         const unsigned sclamp =
             std::is_signed<OutType>::value ? 0xffff : 0x7fff;
 
@@ -702,11 +673,7 @@ void DataInfoSpec<InType, OutType, InFP, OutFP>::init(const cl_uint &job_id,
 
         for (unsigned i = start; i < size; i++)
         {
-            unsigned ind = i % (s_size * e_size * m_size);
-            o[i] = static_cast<InType>((((ind / (e_size * m_size)) << 15)
-                                        | (((ind / m_size) % e_size + 1) << 10)
-                                        | (ind % m_size + 1))
-                                       & sclamp);
+            o[i] = static_cast<InType>(i % sclamp);
         }
     }
     else if (std::is_integral<InType>::value)
@@ -864,8 +831,6 @@ void DataInfoSpec<InType, OutType, InFP, OutFP>::init(const cl_uint &job_id,
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 template <typename InType, typename OutType, bool InFP, bool OutFP>
 InType DataInfoSpec<InType, OutType, InFP, OutFP>::clamp(const InType &in)
 {
@@ -885,6 +850,4 @@ InType DataInfoSpec<InType, OutType, InFP, OutFP>::clamp(const InType &in)
     return in;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-
 #endif /* CONVERSIONS_DATA_INFO_H */
diff --git a/test_conformance/conversions/test_conversions.cpp b/test_conformance/conversions/test_conversions.cpp
index 6d4265cfc..88dca69fd 100644
--- a/test_conformance/conversions/test_conversions.cpp
+++ b/test_conformance/conversions/test_conversions.cpp
@@ -54,10 +54,8 @@
 #include "Sleep.h"
 
 #include "basic_test_conversions.h"
-#include <limits.h>
-#include <string.h>
-
-#include "harness/mt19937.h"
+#include <climits>
+#include <cstring>
 
 #if (defined(__arm__) || defined(__aarch64__)) && defined(__GNUC__)
 #include "fplib.h"
@@ -70,13 +68,11 @@ bool qcom_sat;
 roundingMode qcom_rm;
 #endif
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 static int ParseArgs(int argc, const char **argv);
 static void PrintUsage(void);
 test_status InitCL(cl_device_id device);
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 const char *gTypeNames[kTypeCount] = { "uchar",  "char",  "ushort", "short",
                                        "uint",   "int",   "half",   "float",
@@ -96,7 +92,6 @@ size_t gTypeSizes[kTypeCount] = {
 char appName[64] = "ctest";
 int gMultithread = 1;
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 int test_conversions(cl_device_id device, cl_context context,
                      cl_command_queue queue, int num_elements)
@@ -113,7 +108,6 @@ int test_conversions(cl_device_id device, cl_context context,
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 test_definition test_list[] = {
     ADD_TEST(conversions),
@@ -121,7 +115,6 @@ test_definition test_list[] = {
 
 const int test_num = ARRAY_SIZE(test_list);
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 int main(int argc, const char **argv)
 {
@@ -179,7 +172,6 @@ int main(int argc, const char **argv)
     return ret;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 static int ParseArgs(int argc, const char **argv)
 {
@@ -330,7 +322,6 @@ static int ParseArgs(int argc, const char **argv)
     return 0;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 static void PrintUsage(void)
 {
@@ -369,7 +360,6 @@ static void PrintUsage(void)
         "number can be then passed to indicate how many tests to run\n\n");
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
 
 test_status InitCL(cl_device_id device)
 {
@@ -568,5 +558,3 @@ test_status InitCL(cl_device_id device)
     vlog("\n");
     return TEST_PASS;
 }
-
-////////////////////////////////////////////////////////////////////////////////////////