diff --git a/conformance_filters/codeplay.csv b/conformance_filters/codeplay.csv
index 911f68ada..ae43ed620 100644
--- a/conformance_filters/codeplay.csv
+++ b/conformance_filters/codeplay.csv
@@ -39,4 +39,3 @@ vector_constructors
 vector_operators
 vector_swizzle_assignment
 vector_swizzles
-vector_swizzles_opencl
diff --git a/conformance_filters/core.csv b/conformance_filters/core.csv
index a70a991a2..2b5f375f7 100644
--- a/conformance_filters/core.csv
+++ b/conformance_filters/core.csv
@@ -41,5 +41,4 @@ vector_load_store
 vector_operators
 vector_swizzle_assignment
 vector_swizzles
-vector_swizzles_opencl
 usm
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e8b12d96e..a2c13eee4 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -52,32 +52,6 @@ function(get_std_type OUT_LIST)
   set(${OUT_LIST} ${${OUT_LIST}} ${STD_TYPE_LIST} PARENT_SCOPE)
 endfunction()
 
-function(get_opencl_type OUT_LIST)
-  set(OPENCL_TYPE_LIST "")
-  list(APPEND OPENCL_TYPE_LIST
-    cl::sycl::cl_char
-    cl::sycl::cl_uchar)
-
-  list(APPEND OPENCL_TYPE_LIST
-    cl::sycl::cl_short
-    cl::sycl::cl_ushort)
-
-  list(APPEND OPENCL_TYPE_LIST
-    cl::sycl::cl_int
-    cl::sycl::cl_uint)
-
-  list(APPEND OPENCL_TYPE_LIST
-    cl::sycl::cl_long
-    cl::sycl::cl_ulong)
-
-  list(APPEND OPENCL_TYPE_LIST
-    cl::sycl::cl_float
-    cl::sycl::cl_double
-    cl::sycl::cl_half)
-
-  set(${OUT_LIST} ${${OUT_LIST}} ${OPENCL_TYPE_LIST} PARENT_SCOPE)
-endfunction()
-
 function(get_no_vec_alias_type OUT_LIST)
   set(NO_VEC_ALIAS_LIST "")
   list(APPEND NO_VEC_ALIAS_LIST cl::sycl::byte)
@@ -101,11 +75,11 @@ endfunction()
 
 macro(half_double_filter list)
   if(NOT SYCL_CTS_ENABLE_DOUBLE_TESTS)
-    list(REMOVE_ITEM ${list} double cl::sycl::cl_double)
+    list(REMOVE_ITEM ${list} double)
   endif()
 
   if(NOT SYCL_CTS_ENABLE_HALF_TESTS)
-    list(REMOVE_ITEM ${list} cl::sycl::half cl::sycl::cl_half)
+    list(REMOVE_ITEM ${list} cl::sycl::half)
   endif()
 
 endmacro()
diff --git a/tests/common/common_python_vec.py b/tests/common/common_python_vec.py
index 02ecf43e9..1484b137f 100644
--- a/tests/common/common_python_vec.py
+++ b/tests/common/common_python_vec.py
@@ -59,37 +59,6 @@ class Data:
         ('std::int64_t'): 'INT32_MAX'
     }
 
-    opencl_types = [
-        'cl::sycl::cl_char', 'cl::sycl::cl_short', 'cl::sycl::cl_int',
-        'cl::sycl::cl_long', 'cl::sycl::cl_float', 'cl::sycl::cl_double',
-        'cl::sycl::cl_half'
-    ]
-    opencl_type_dict = {
-        (False, 'cl::sycl::cl_char'): 'cl::sycl::cl_uchar',
-        (True, 'cl::sycl::cl_char'): 'cl::sycl::cl_char',
-        (False, 'cl::sycl::cl_short'): 'cl::sycl::cl_ushort',
-        (True, 'cl::sycl::cl_short'): 'cl::sycl::cl_short',
-        (False, 'cl::sycl::cl_int'): 'cl::sycl::cl_uint',
-        (True, 'cl::sycl::cl_int'): 'cl::sycl::cl_int',
-        (False, 'cl::sycl::cl_long'): 'cl::sycl::cl_ulong',
-        (True, 'cl::sycl::cl_long'): 'cl::sycl::cl_long',
-        (True, 'cl::sycl::cl_float'): 'cl::sycl::cl_float',
-        (True, 'cl::sycl::cl_double'): 'cl::sycl::cl_double',
-        (True, 'cl::sycl::cl_half'): 'cl::sycl::cl_half'
-    }
-    opencl_sized_return_type_dict = {
-        'cl::sycl::cl_char': 'cl::sycl::cl_char',
-        'cl::sycl::cl_uchar': 'cl::sycl::cl_char',
-        'cl::sycl::cl_short': 'cl::sycl::cl_short',
-        'cl::sycl::cl_ushort': 'cl::sycl::cl_short',
-        'cl::sycl::cl_half': 'cl::sycl::cl_short',
-        'cl::sycl::cl_int': 'cl::sycl::cl_int',
-        'cl::sycl::cl_uint': 'cl::sycl::cl_int',
-        'cl::sycl::cl_float': 'cl::sycl::cl_int',
-        'cl::sycl::cl_long': 'cl::sycl::cl_long',
-        'cl::sycl::cl_ulong': 'cl::sycl::cl_long',
-        'cl::sycl::cl_double': 'cl::sycl::cl_long'
-    }
     alias_dict = {
         'char': 'cl::sycl::char',
         'signed char': 'cl::sycl::schar',
@@ -104,26 +73,12 @@ class Data:
         'unsigned long long': 'cl::sycl::ulonglong',
         'float': 'cl::sycl::float',
         'double': 'cl::sycl::double',
-        'cl::sycl::half': 'cl::sycl::half',
-        'cl::sycl::cl_char': 'cl::sycl::cl_char',
-        'cl::sycl::cl_uchar': 'cl::sycl::cl_uchar',
-        'cl::sycl::cl_short': 'cl::sycl::cl_short',
-        'cl::sycl::cl_ushort': 'cl::sycl::cl_ushort',
-        'cl::sycl::cl_int': 'cl::sycl::cl_int',
-        'cl::sycl::cl_uint': 'cl::sycl::cl_uint',
-        'cl::sycl::cl_long': 'cl::sycl::cl_long',
-        'cl::sycl::cl_ulong': 'cl::sycl::cl_ulong',
-        'cl::sycl::cl_float': 'cl::sycl::cl_float',
-        'cl::sycl::cl_double': 'cl::sycl::cl_double',
-        'cl::sycl::cl_half': 'cl::sycl::cl_half'
+        'cl::sycl::half': 'cl::sycl::half'
     }
     value_default_dict = defaultdict(lambda: '0', {
         'float': '0.0f',
         'double': '0.0',
-        'cl::sycl::half': '0.0f',
-        'cl::sycl::cl_float': '0.0f',
-        'cl::sycl::cl_double': '0.0',
-        'cl::sycl::cl_half': '0.0f'
+        'cl::sycl::half': '0.0f'
     })
     vec_name_dict = {
         1: 'One',
@@ -194,7 +149,6 @@ class Data:
 
 class ReverseData:
     rev_standard_type_dict = { Data.standard_type_dict[k] : k for k in list(Data.standard_type_dict.keys()) }
-    rev_opencl_type_dict = { Data.opencl_type_dict[k] : k for k in list(Data.opencl_type_dict.keys()) }
     rev_fixed_width_type_dict = { Data.fixed_width_type_dict[k] : k for k in list(Data.fixed_width_type_dict.keys()) }
 
 
@@ -308,11 +262,10 @@ def append_fp_postfix(type_str, input_val_list):
     to each value in the list if type_str is 'float', 'double' or 'cl::sycl::half'"""
     result_val_list = []
     for val in input_val_list:
-        if (type_str == 'float' or type_str == 'cl::sycl::cl_float'
-                or type_str == 'cl::sycl::half'
-                or type_str == 'cl::sycl::cl_half'):
+        if (type_str == 'float'
+                or type_str == 'cl::sycl::half'):
             result_val_list.append(val + '.0f')
-        elif type_str == 'double' or type_str == 'cl::sycl::cl_double':
+        elif type_str == 'double':
             result_val_list.append(val + '.0')
         else:
             result_val_list.append(val)
@@ -401,7 +354,7 @@ def write_source_file(test_str, func_calls, test_name, input_file, output_file,
     with open(output_file, 'w+') as output:
         output.write(source)
 
-def get_standard_and_fixed_width_types():
+def get_types():
     types = ['char', 'cl::sycl::byte']
     for base_type in Data.standard_types:
         for sign in Data.signs:
@@ -415,24 +368,6 @@ def get_standard_and_fixed_width_types():
             types.append(Data.fixed_width_type_dict[(sign, base_type)])
     return types
 
-def get_opencl_types():
-    types = list()
-    for base_type in Data.opencl_types:
-        for sign in Data.signs:
-            if (base_type == 'cl::sycl::cl_float'
-                    or base_type == 'cl::sycl::cl_double'
-                    or base_type == 'cl::sycl::cl_half') and sign is False:
-                continue
-            types.append(Data.opencl_type_dict[(sign, base_type)])
-    return types
-
-def get_types():
-    types = list()
-    types += get_standard_and_fixed_width_types()
-    types += get_opencl_types()
-
-    return types
-
 class SwizzleData:
     swizzle_template = Template(
         """        cl::sycl::vec<${type}, ${size}> ${name}DimTestVec = cl::sycl::vec<${type}, ${size}>(${testVecValues});
@@ -450,7 +385,7 @@ class SwizzleData:
             if (!check_vector_values<${type}, ${size}>(swizzledVec, in_order_vals)) {
                 resAcc[0] = false;
             }
-            if (!check_vector_get_count_get_size<${type}>(swizzledVec)) {
+            if (!check_vector_get_count_get_size<${type}, ${size}>(swizzledVec)) {
                 resAcc[0] = false;
             }
 #ifdef SYCL_CTS_EXTENSIVE_MODE
@@ -498,7 +433,7 @@ class SwizzleData:
             if (!check_vector_values<${type}, ${size}>(inOrderSwizzleFunctionVec, in_order_vals)) {
                 resAcc[0] = false;
             }
-            if (!check_vector_get_count_get_size<${type}>(inOrderSwizzleFunctionVec)) {
+            if (!check_vector_get_count_get_size<${type}, ${size}>(inOrderSwizzleFunctionVec)) {
                 resAcc[0] = false;
             }
 #ifdef SYCL_CTS_EXTENSIVE_MODE
@@ -518,7 +453,7 @@ class SwizzleData:
             if (!check_vector_values<${type}, ${size}>(reverseOrderSwizzleFunctionVec, reversed_vals)) {
                 resAcc[0] = false;
             }
-            if (!check_vector_get_count_get_size<${type}>(reverseOrderSwizzleFunctionVec)) {
+            if (!check_vector_get_count_get_size<${type}, ${size}>(reverseOrderSwizzleFunctionVec)) {
                 resAcc[0] = false;
             }
 #ifdef SYCL_CTS_EXTENSIVE_MODE
@@ -538,7 +473,7 @@ class SwizzleData:
             if (!check_vector_values<${type}, ${size}>(inOrderReversedPairSwizzleFunctionVec, in_order_reversed_pair_vals)) {
                 resAcc[0] = false;
             }
-            if (!check_vector_get_count_get_size<${type}>(inOrderReversedPairSwizzleFunctionVec)) {
+            if (!check_vector_get_count_get_size<${type}, ${size}>(inOrderReversedPairSwizzleFunctionVec)) {
                 resAcc[0] = false;
             }
 #ifdef SYCL_CTS_EXTENSIVE_MODE
@@ -558,7 +493,7 @@ class SwizzleData:
             if (!check_vector_values<${type}, ${size}>(reverseOrderReversedPairSwizzleFunctionVec, reverse_order_reversed_pair_vals)) {
                 resAcc[0] = false;
             }
-            if (!check_vector_get_count_get_size<${type}>(reverseOrderReversedPairSwizzleFunctionVec)) {
+            if (!check_vector_get_count_get_size<${type}, ${size}>(reverseOrderReversedPairSwizzleFunctionVec)) {
                 resAcc[0] = false;
             }
 #ifdef SYCL_CTS_EXTENSIVE_MODE
@@ -674,15 +609,9 @@ def write_swizzle_source_file(swizzles, input_file, output_file, type_str):
     with open(input_file, 'r') as source_file:
         source = source_file.read()
 
-    is_opencl_type = type_str in ReverseData.rev_opencl_type_dict
-
     source = replace_string_in_source_string(source,
                                             remove_namespaces_whitespaces(type_str),
                                             '$TYPE_NAME')
-    if is_opencl_type:
-        source = source.replace('$OPENCL', 'opencl_')
-    else:
-        source = source.replace('$OPENCL', '')
 
     source = replace_string_in_source_string(source, swizzles[0],
                                              '$1D_SWIZZLES')
@@ -709,12 +638,8 @@ def get_reverse_type(type_str):
         type_dict =  Data.standard_type_dict
         rev_type_dict = ReverseData.rev_standard_type_dict
     else:
-        if type_str in ReverseData.rev_opencl_type_dict:
-            type_dict =  Data.opencl_type_dict
-            rev_type_dict = ReverseData.rev_opencl_type_dict
-        else:
-            type_dict =  Data.fixed_width_type_dict
-            rev_type_dict = ReverseData.rev_fixed_width_type_dict
+        type_dict =  Data.fixed_width_type_dict
+        rev_type_dict = ReverseData.rev_fixed_width_type_dict
     (sign, base_type) = rev_type_dict[type_str]
     if (not sign, base_type) in type_dict:
         reverse_type_str = type_dict[(not sign, base_type)]
diff --git a/tests/common/common_vec.h b/tests/common/common_vec.h
index 385ccaa67..a9a491ba9 100644
--- a/tests/common/common_vec.h
+++ b/tests/common/common_vec.h
@@ -107,35 +107,6 @@ bool check_single_vector_op(vectorType vector1, lambdaFunc lambda) {
   return true;
 }
 
-/**
- * @brief Helper function to test the following functions of a vec
- * get_count()
- * get_size()
- */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 1> inputVec) {
-  // get_count()
-  int count = inputVec.get_count();
-  if (count != 1) {
-    return false;
-  }
-  count = inputVec.template swizzle<cl::sycl::elem::s0>().get_count();
-  if (count != 1) {
-    return false;
-  }
-
-  // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 1) {
-    return false;
-  }
-  size = inputVec.template swizzle<cl::sycl::elem::s0>().get_size();
-  if (size != sizeof(vecType) * 1) {
-    return false;
-  }
-  return true;
-}
-
 // match float values to expected integer value
 template <typename T1, typename T2>
 T2 float_map_match(T1 floats[], T2 vals[], int size, T1 src) {
@@ -147,13 +118,6 @@ T2 float_map_match(T1 floats[], T2 vals[], int size, T1 src) {
   return T2{};
 }
 
-template <typename T>
-static constexpr bool is_unsigned_type_v =
-    std::is_unsigned_v<T> || std::is_same_v<T, cl::sycl::cl_uchar> ||
-    std::is_same_v<T, cl::sycl::cl_uint> ||
-    std::is_same_v<T, cl::sycl::cl_ulong> ||
-    std::is_same_v<T, cl::sycl::cl_ushort>;
-
 template <typename sourceType, typename targetType>
 static constexpr bool if_FP_to_non_FP_conv_v =
     is_cl_float_type<sourceType>::value && !is_cl_float_type<targetType>::value;
@@ -274,7 +238,7 @@ cl::sycl::vec<convertType, N> rtn(cl::sycl::vec<vecType, N> inputVec) {
 template <typename vecType, int N, typename convertType>
 void handleFPToUnsignedConv(cl::sycl::vec<vecType, N>& inputVec) {
   if constexpr (is_cl_float_type<vecType>::value &&
-                is_unsigned_type_v<convertType>) {
+                std::is_unsigned_v<convertType>) {
     for (size_t i = 0; i < N; ++i) {
       vecType elem = getElement(inputVec, i);
       if (elem < 0) setElement<vecType, N>(inputVec, i, -elem);
@@ -284,7 +248,7 @@ void handleFPToUnsignedConv(cl::sycl::vec<vecType, N>& inputVec) {
 
 template <typename vecType, int N, typename convertType,
           cl::sycl::rounding_mode mode>
-bool check_vector_convert(cl::sycl::vec<vecType, N> inputVec) {
+bool check_vector_convert_result(cl::sycl::vec<vecType, N> inputVec) {
   handleFPToUnsignedConv<vecType, N, convertType>(inputVec);
   cl::sycl::vec<convertType, N> convertedVec =
       inputVec.template convert<convertType, mode>();
@@ -316,286 +280,105 @@ bool check_vector_convert(cl::sycl::vec<vecType, N> inputVec) {
 template <typename vecType, int N, typename convertType>
 bool check_vector_convert_modes(cl::sycl::vec<vecType, N> inputVec) {
   bool flag = true;
-  flag &= check_vector_convert<vecType, N, convertType,
-                               cl::sycl::rounding_mode::automatic>(inputVec);
+  flag &=
+      check_vector_convert_result<vecType, N, convertType,
+                                  cl::sycl::rounding_mode::automatic>(inputVec);
 #ifdef SYCL_CTS_ENABLE_FULL_CONFORMANCE
-  flag &= check_vector_convert<vecType, N, convertType,
-                               cl::sycl::rounding_mode::rte>(inputVec);
-  flag &= check_vector_convert<vecType, N, convertType,
-                               cl::sycl::rounding_mode::rtz>(inputVec);
-  flag &= check_vector_convert<vecType, N, convertType,
-                               cl::sycl::rounding_mode::rtp>(inputVec);
-  flag &= check_vector_convert<vecType, N, convertType,
-                               cl::sycl::rounding_mode::rtn>(inputVec);
+  flag &= check_vector_convert_result<vecType, N, convertType,
+                                      cl::sycl::rounding_mode::rte>(inputVec);
+  flag &= check_vector_convert_result<vecType, N, convertType,
+                                      cl::sycl::rounding_mode::rtz>(inputVec);
+  flag &= check_vector_convert_result<vecType, N, convertType,
+                                      cl::sycl::rounding_mode::rtp>(inputVec);
+  flag &= check_vector_convert_result<vecType, N, convertType,
+                                      cl::sycl::rounding_mode::rtn>(inputVec);
 #endif  // SYCL_CTS_ENABLE_FULL_CONFORMANCE
   return flag;
 }
 
-/**
- * @brief Helper function to test the convert() function of a vec
- */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 1> inputVec) {
-  // convert()
-  return check_vector_convert_modes<vecType, 1, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 1, convertType>(
-             inputVec.template swizzle<cl::sycl::elem::s0>());
-}
-
-template <typename vecType, int N, typename asType, int asN>
-asType check_as_result(cl::sycl::vec<vecType, N> inputVec,
-                       cl::sycl::vec<asType, asN> asVec) {
-  vecType tmp_ptr[N];
-  for (size_t i = 0; i < N; ++i) {
-    tmp_ptr[i] = getElement(inputVec, i);
-  }
-  asType* exp_ptr = reinterpret_cast<asType*>(tmp_ptr);
-  for (size_t i = 0; i < asN; ++i) {
-    if (exp_ptr[i] != getElement(asVec, i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * @brief Helper function to test as() function of a vec for asType
- * as()
- */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 1> inputVec) {
-  using asVecType = cl::sycl::vec<asType, asN>;
-  asVecType asVec = inputVec.template as<asVecType>();
-  asVecType asVecSwizzle =
-      inputVec.template swizzle<cl::sycl::elem::s0>().template as<asVecType>();
-  return check_as_result(inputVec, asVec) &&
-         check_as_result(inputVec, asVecSwizzle);
-}
+template <typename T, int N>
+struct vector_swizzle_check {
+  static auto get_swizzle(sycl::vec<T, N>) {}
+};
 
-/**
- * @brief Helper function to test the following functions of a vec
- * get_count()
- * get_size()
- */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 2> inputVec) {
-  // get_count()
-  int count = inputVec.get_count();
-  if (count != 2) {
-    return false;
-  }
-  count = inputVec.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1>()
-              .get_count();
-  if (count != 2) {
-    return false;
+template <typename T>
+struct vector_swizzle_check<T, 1> {
+  static auto get_swizzle(sycl::vec<T, 1> v) {
+    return v.template swizzle<cl::sycl::elem::s0>();
   }
+};
 
-  // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 2) {
-    return false;
-  }
-  size = inputVec.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1>()
-             .get_size();
-  if (size != sizeof(vecType) * 2) {
-    return false;
+template <typename T>
+struct vector_swizzle_check<T, 2> {
+  static auto get_swizzle(sycl::vec<T, 2> v) {
+    return v.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1>();
   }
-  return true;
-}
-
-/**
- * @brief Helper function to test the convert() function of a vec
- */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 2> inputVec) {
-  // convert()
-  return check_vector_convert_modes<vecType, 2, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 2, convertType>(
-             inputVec
-                 .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1>());
-}
-
-/**
- * @brief Helper function to test as() function of a vec for asType
- * as()
- */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 2> inputVec) {
-  // as()
-  using asVecType = cl::sycl::vec<asType, asN>;
-  asVecType asVec = inputVec.template as<asVecType>();
-  asVecType asVecSwizzle =
-      inputVec.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1>()
-          .template as<asVecType>();
-  return check_as_result(inputVec, asVec) &&
-         check_as_result(inputVec, asVecSwizzle);
-}
+};
 
-/**
- * @brief Helper function to test the following functions of a vec
- * get_count()
- * get_size()
- */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 3> inputVec) {
-  // get_count()
-  int count = inputVec.get_count();
-  if (count != 3) {
-    return false;
-  }
-  count = inputVec
-              .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                                cl::sycl::elem::s2>()
-              .get_count();
-  if (count != 3) {
-    return false;
+template <typename T>
+struct vector_swizzle_check<T, 3> {
+  static auto get_swizzle(sycl::vec<T, 3> v) {
+    return v.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
+                              cl::sycl::elem::s2>();
   }
+};
 
-  // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 4) {
-    return false;
-  }
-  size = inputVec
-             .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                               cl::sycl::elem::s2>()
-             .get_size();
-  if (size != sizeof(vecType) * 4) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * @brief Helper function to test the convert() function of a vec
- */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 3> inputVec) {
-  // convert()
-  return check_vector_convert_modes<vecType, 3, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 3, convertType>(
-             inputVec.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                                       cl::sycl::elem::s2>());
-}
-
-/**
- * @brief Helper function to test as() function of a vec for asType
- * as()
- */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 3> inputVec) {
-  // as()
-  using asVecType = cl::sycl::vec<asType, asN>;
-  asVecType asVec = inputVec.template as<asVecType>();
-  asVecType asVecSwizzle =
-      inputVec
-          .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                            cl::sycl::elem::s2>()
-          .template as<asVecType>();
-  return check_as_result(inputVec, asVec) &&
-         check_as_result(inputVec, asVecSwizzle);
-}
-
-/**
- * @brief Helper function to test the following functions of a vec
- * get_count()
- * get_size()
- */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 4> inputVec) {
-  // get_count()
-  int count = inputVec.get_count();
-  if (count != 4) {
-    return false;
-  }
-  count = inputVec
-              .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                                cl::sycl::elem::s2, cl::sycl::elem::s3>()
-              .get_count();
-  if (count != 4) {
-    return false;
+template <typename T>
+struct vector_swizzle_check<T, 4> {
+  static auto get_swizzle(sycl::vec<T, 4> v) {
+    return v.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
+                              cl::sycl::elem::s2, cl::sycl::elem::s3>();
   }
+};
 
-  // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 4) {
-    return false;
-  }
-  size = inputVec
-             .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                               cl::sycl::elem::s2, cl::sycl::elem::s3>()
-             .get_size();
-  if (size != sizeof(vecType) * 4) {
-    return false;
+template <typename T>
+struct vector_swizzle_check<T, 8> {
+  static auto get_swizzle(sycl::vec<T, 8> v) {
+    return v.template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
+                              cl::sycl::elem::s2, cl::sycl::elem::s3,
+                              cl::sycl::elem::s4, cl::sycl::elem::s5,
+                              cl::sycl::elem::s6, cl::sycl::elem::s7>();
   }
-  return true;
-}
+};
 
-/**
- * @brief Helper function to test the convert() function of a vec
- */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 4> inputVec) {
-  // convert()
-  return check_vector_convert_modes<vecType, 4, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 4, convertType>(
-             inputVec
-                 .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                                   cl::sycl::elem::s2, cl::sycl::elem::s3>());
-}
-
-/**
- * @brief Helper function to test as() function of a vec for asType
- * as()
- */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 4> inputVec) {
-  // as()
-  using asVecType = cl::sycl::vec<asType, asN>;
-  asVecType asVec = inputVec.template as<asVecType>();
-  asVecType asVecSwizzle =
-      inputVec
-          .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                            cl::sycl::elem::s2, cl::sycl::elem::s3>()
-          .template as<asVecType>();
-  return check_as_result(inputVec, asVec) &&
-         check_as_result(inputVec, asVecSwizzle);
-}
+template <typename T>
+struct vector_swizzle_check<T, 16> {
+  static auto get_swizzle(sycl::vec<T, 16> v) {
+    return v.template swizzle<
+        cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
+        cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
+        cl::sycl::elem::s6, cl::sycl::elem::s7, cl::sycl::elem::s8,
+        cl::sycl::elem::s9, cl::sycl::elem::sA, cl::sycl::elem::sB,
+        cl::sycl::elem::sC, cl::sycl::elem::sD, cl::sycl::elem::sE,
+        cl::sycl::elem::sF>();
+  }
+};
 
 /**
  * @brief Helper function to test the following functions of a vec
  * get_count()
  * get_size()
  */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 8> inputVec) {
+template <typename vecType, int N>
+bool check_vector_get_count_get_size(cl::sycl::vec<vecType, N> inputVec) {
   // get_count()
-  int count = inputVec.get_count();
-  if (count != 8) {
+  size_t count = inputVec.get_count();
+  if (count != N) {
     return false;
   }
-  count = inputVec
-              .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                                cl::sycl::elem::s2, cl::sycl::elem::s3,
-                                cl::sycl::elem::s4, cl::sycl::elem::s5,
-                                cl::sycl::elem::s6, cl::sycl::elem::s7>()
-              .get_count();
-  if (count != 8) {
+  count = vector_swizzle_check<vecType, N>::get_swizzle(inputVec).get_count();
+  if (count != N) {
     return false;
   }
 
   // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 8) {
+  size_t size = inputVec.get_size();
+  size_t M = (N == 3) ? 4 : N;
+  if (size != sizeof(vecType) * M) {
     return false;
   }
-  size = inputVec
-             .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                               cl::sycl::elem::s2, cl::sycl::elem::s3,
-                               cl::sycl::elem::s4, cl::sycl::elem::s5,
-                               cl::sycl::elem::s6, cl::sycl::elem::s7>()
-             .get_size();
-  if (size != sizeof(vecType) * 8) {
+  size = vector_swizzle_check<vecType, N>::get_swizzle(inputVec).get_size();
+  if (size != sizeof(vecType) * M) {
     return false;
   }
   return true;
@@ -604,117 +387,40 @@ bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 8> inputVec) {
 /**
  * @brief Helper function to test the convert() function of a vec
  */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 8> inputVec) {
+template <typename vecType, int N, typename convertType>
+bool check_vector_convert(cl::sycl::vec<vecType, N> inputVec) {
   // convert()
-  return check_vector_convert_modes<vecType, 8, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 8, convertType>(
-             inputVec.template swizzle<
-                 cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
-                 cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
-                 cl::sycl::elem::s6, cl::sycl::elem::s7>());
+  return check_vector_convert_modes<vecType, N, convertType>(inputVec) &&
+         check_vector_convert_modes<vecType, N, convertType>(
+             vector_swizzle_check<vecType, N>::get_swizzle(inputVec));
 }
 
-/**
- * @brief Helper function to test as() function of a vec for asType
- * as()
- */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 8> inputVec) {
-  // as()
-  using asVecType = cl::sycl::vec<asType, asN>;
-  asVecType asVec = inputVec.template as<asVecType>();
-  asVecType asVecSwizzle =
-      inputVec
-          .template swizzle<cl::sycl::elem::s0, cl::sycl::elem::s1,
-                            cl::sycl::elem::s2, cl::sycl::elem::s3,
-                            cl::sycl::elem::s4, cl::sycl::elem::s5,
-                            cl::sycl::elem::s6, cl::sycl::elem::s7>()
-          .template as<asVecType>();
-  return check_as_result(inputVec, asVec) &&
-         check_as_result(inputVec, asVecSwizzle);
-}
-
-/**
- * @brief Helper function to test the following functions of a vec
- * get_count()
- * get_size()
- */
-template <typename vecType>
-bool check_vector_get_count_get_size(cl::sycl::vec<vecType, 16> inputVec) {
-  // get_count()
-  int count = inputVec.get_count();
-  if (count != 16) {
-    return false;
-  }
-  count = inputVec
-              .template swizzle<
-                  cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
-                  cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
-                  cl::sycl::elem::s6, cl::sycl::elem::s7, cl::sycl::elem::s8,
-                  cl::sycl::elem::s9, cl::sycl::elem::sA, cl::sycl::elem::sB,
-                  cl::sycl::elem::sC, cl::sycl::elem::sD, cl::sycl::elem::sE,
-                  cl::sycl::elem::sF>()
-              .get_count();
-  if (count != 16) {
-    return false;
-  }
-
-  // get_size()
-  int size = inputVec.get_size();
-  if (size != sizeof(vecType) * 16) {
-    return false;
+template <typename vecType, int N, typename asType, int asN>
+asType check_as_result(cl::sycl::vec<vecType, N> inputVec,
+                       cl::sycl::vec<asType, asN> asVec) {
+  vecType tmp_ptr[N];
+  for (size_t i = 0; i < N; ++i) {
+    tmp_ptr[i] = getElement(inputVec, i);
   }
-  size = inputVec
-             .template swizzle<
-                 cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
-                 cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
-                 cl::sycl::elem::s6, cl::sycl::elem::s7, cl::sycl::elem::s8,
-                 cl::sycl::elem::s9, cl::sycl::elem::sA, cl::sycl::elem::sB,
-                 cl::sycl::elem::sC, cl::sycl::elem::sD, cl::sycl::elem::sE,
-                 cl::sycl::elem::sF>()
-             .get_size();
-  if (size != sizeof(vecType) * 16) {
-    return false;
+  asType* exp_ptr = reinterpret_cast<asType*>(tmp_ptr);
+  for (size_t i = 0; i < asN; ++i) {
+    if (exp_ptr[i] != getElement(asVec, i)) {
+      return false;
+    }
   }
   return true;
 }
 
-/**
- * @brief Helper function to test the convert() function of a vec
- */
-template <typename vecType, typename convertType>
-bool check_vector_convert(cl::sycl::vec<vecType, 16> inputVec) {
-  // convert()
-  return check_vector_convert_modes<vecType, 16, convertType>(inputVec) &&
-         check_vector_convert_modes<vecType, 16, convertType>(
-             inputVec.template swizzle<
-                 cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
-                 cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
-                 cl::sycl::elem::s6, cl::sycl::elem::s7, cl::sycl::elem::s8,
-                 cl::sycl::elem::s9, cl::sycl::elem::sA, cl::sycl::elem::sB,
-                 cl::sycl::elem::sC, cl::sycl::elem::sD, cl::sycl::elem::sE,
-                 cl::sycl::elem::sF>());
-}
-
 /**
  * @brief Helper function to test as() function of a vec for asType
  * as()
  */
-template <typename vecType, typename asType, int asN>
-bool check_vector_as(cl::sycl::vec<vecType, 16> inputVec) {
-  // as()
+template <typename vecType, int N, typename asType, int asN>
+bool check_vector_as(cl::sycl::vec<vecType, N> inputVec) {
   using asVecType = cl::sycl::vec<asType, asN>;
   asVecType asVec = inputVec.template as<asVecType>();
   asVecType asVecSwizzle =
-      inputVec
-          .template swizzle<
-              cl::sycl::elem::s0, cl::sycl::elem::s1, cl::sycl::elem::s2,
-              cl::sycl::elem::s3, cl::sycl::elem::s4, cl::sycl::elem::s5,
-              cl::sycl::elem::s6, cl::sycl::elem::s7, cl::sycl::elem::s8,
-              cl::sycl::elem::s9, cl::sycl::elem::sA, cl::sycl::elem::sB,
-              cl::sycl::elem::sC, cl::sycl::elem::sD, cl::sycl::elem::sE,
-              cl::sycl::elem::sF>()
+      vector_swizzle_check<vecType, N>::get_swizzle(inputVec)
           .template as<asVecType>();
   return check_as_result(inputVec, asVec) &&
          check_as_result(inputVec, asVecSwizzle);
@@ -728,7 +434,7 @@ template <typename vecType, int N, typename asType, int asN>
 bool check_vectorN_as(cl::sycl::vec<vecType, N> inputVec) {
   if constexpr (sizeof(cl::sycl::vec<vecType, N>) ==
                 sizeof(cl::sycl::vec<asType, asN>))
-    return check_vector_as<vecType, asType, asN>(inputVec);
+    return check_vector_as<vecType, N, asType, asN>(inputVec);
   else
     return true;
 }
@@ -740,7 +446,7 @@ bool check_vectorN_as(cl::sycl::vec<vecType, N> inputVec) {
 template <typename vecType, int N, typename newVecType>
 bool check_convert_as_all_dims(cl::sycl::vec<vecType, N> inputVec) {
   bool result = true;
-  result += check_vector_convert<vecType, newVecType>(inputVec);
+  result += check_vector_convert<vecType, N, newVecType>(inputVec);
 
   result += check_vectorN_as<vecType, N, newVecType, 1>(inputVec);
   result += check_vectorN_as<vecType, N, newVecType, 2>(inputVec);
@@ -774,17 +480,6 @@ bool check_convert_as_all_types(cl::sycl::vec<vecType, N> inputVec) {
 #ifdef SYCL_CTS_ENABLE_FULL_CONFORMANCE
   result += check_convert_as_all_dims<vecType, N, cl::sycl::byte>(inputVec);
 
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_char>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_uchar>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_short>(inputVec);
-  result +=
-      check_convert_as_all_dims<vecType, N, cl::sycl::cl_ushort>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_int>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_uint>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_long>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_ulong>(inputVec);
-  result += check_convert_as_all_dims<vecType, N, cl::sycl::cl_float>(inputVec);
-
 #ifdef INT8_MAX
   result += check_convert_as_all_dims<vecType, N, std::int8_t>(inputVec);
 #endif
diff --git a/tests/common/vector_swizzles.template b/tests/common/vector_swizzles.template
index 3e7b15d91..7151bfd60 100644
--- a/tests/common/vector_swizzles.template
+++ b/tests/common/vector_swizzles.template
@@ -11,9 +11,9 @@ $IFDEF
 #include "../common/common.h"
 #include "../common/common_vec.h"
 
-#define TEST_NAME vector_swizzles_$OPENCL$TYPE_NAME
+#define TEST_NAME vector_swizzles_$TYPE_NAME
 
-namespace vector_swizzles_$OPENCL$TYPE_NAME__ {
+namespace vector_swizzles_$TYPE_NAME__ {
 using namespace sycl_cts;
 
 /** Test each combination of vector swizzles can be generated
diff --git a/tests/vector_alias/CMakeLists.txt b/tests/vector_alias/CMakeLists.txt
index 2f84a4d39..979c866ea 100644
--- a/tests/vector_alias/CMakeLists.txt
+++ b/tests/vector_alias/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 
 foreach(TY IN LISTS TYPE_LIST)
   set(OUT_FILE "vector_alias_${TY}.cpp")
diff --git a/tests/vector_alias/generate_vector_alias.py b/tests/vector_alias/generate_vector_alias.py
index b6a2c56b8..f4c60d9c3 100755
--- a/tests/vector_alias/generate_vector_alias.py
+++ b/tests/vector_alias/generate_vector_alias.py
@@ -50,14 +50,6 @@ def get_types():
                 or base_type == 'cl::sycl::half') and sign is False:
                 continue
             types.append(Data.standard_type_dict[(sign, base_type)])
-
-    for base_type in Data.opencl_types:
-        for sign in Data.signs:
-            if (base_type == 'cl::sycl::cl_float'
-                    or base_type == 'cl::sycl::cl_double'
-                    or base_type == 'cl::sycl::cl_half') and sign is False:
-                continue
-            types.append(Data.opencl_type_dict[(sign, base_type)])
     return types
 
 def main():
diff --git a/tests/vector_api/CMakeLists.txt b/tests/vector_api/CMakeLists.txt
index a0fc989d1..4c2ef62ad 100644
--- a/tests/vector_api/CMakeLists.txt
+++ b/tests/vector_api/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 get_no_vec_alias_type(TYPE_LIST)
 
 if(SYCL_CTS_ENABLE_FULL_CONFORMANCE)
@@ -13,12 +12,12 @@ else()
 endif()
 
 if(NOT SYCL_CTS_ENABLE_DOUBLE_TESTS)
-    list(REMOVE_ITEM TYPE_LIST double cl::sycl::cl_double)
+    list(REMOVE_ITEM TYPE_LIST double)
     STRING(REGEX REPLACE "64" "" ENABLE_AS_CONVERT_TYPES ${ENABLE_AS_CONVERT_TYPES})
 endif()
 
 if(NOT SYCL_CTS_ENABLE_HALF_TESTS)
-    list(REMOVE_ITEM TYPE_LIST cl::sycl::half cl::sycl::cl_half)
+    list(REMOVE_ITEM TYPE_LIST cl::sycl::half)
     STRING(REGEX REPLACE "16" "" ENABLE_AS_CONVERT_TYPES ${ENABLE_AS_CONVERT_TYPES})
 endif()
 
diff --git a/tests/vector_api/generate_vector_api.py b/tests/vector_api/generate_vector_api.py
index 15f48c265..45e44b749 100755
--- a/tests/vector_api/generate_vector_api.py
+++ b/tests/vector_api/generate_vector_api.py
@@ -20,7 +20,7 @@
 vector_api_template = Template("""
         auto inputVec = cl::sycl::vec<${type}, ${size}>(${vals});
         ${type} reversed_vals[] = {${reversed_vals}};
-        if (!check_vector_get_count_get_size<${type}>(inputVec)) {
+        if (!check_vector_get_count_get_size<${type}, ${size}>(inputVec)) {
           resAcc[0] = false;
         }
         cl::sycl::vec<${type}, ${size}> swizzledVec {inputVec.template swizzle<${swizIndexes}>()};
@@ -45,8 +45,7 @@
 
 as_convert_call_template = Template("""
         auto inputVec = cl::sycl::vec<${type}, ${size}>(${vals});
-        if (!check_convert_as_all_dims<${type}, ${size}, ${dest_type1}>(inputVec) ||
-            !check_convert_as_all_dims<${type}, ${size}, ${dest_type2}>(inputVec)) {
+        if (!check_convert_as_all_dims<${type}, ${size}, ${dest_type1}>(inputVec)) {
             resAcc[0] = false;
         }
 """)
@@ -67,13 +66,9 @@ def gen_checks(type_str, size):
     if 'double' in type_str:
         test_string += 'check_convert_as_all_dims<'+type_str +','+ str(
                 size) + ', double>(inputVec);\n'
-        test_string += 'check_convert_as_all_dims<'+type_str +','+ str(
-                size) + ', cl::sycl::cl_double>(inputVec);\n'
     if 'half' in type_str:
         test_string += 'check_convert_as_all_dims<'+type_str +','+ str(
                 size) + ', cl::sycl::half>(inputVec);\n'
-        test_string += 'check_convert_as_all_dims<'+type_str +','+ str(
-                size) + ', cl::sycl::cl_half>(inputVec);\n'
     if size != 1:
         test_string += lo_hi_odd_even_template.substitute(
         type=type_str,
@@ -84,27 +79,26 @@ def gen_checks(type_str, size):
         test_string)
     return wrap_with_test_func(TEST_NAME, type_str, string, str(size))
 
-def gen_optional_checks(type_str, size, dest, dest_types, TEST_NAME_OP):
+def gen_optional_checks(type_str, size, dest, dest_type, TEST_NAME_OP):
     kernel_name = 'KERNEL_CONVERT_AS_' + type_str + str(size) + dest
     test_string = as_convert_call_template.substitute(
         type=type_str,
         size=size,
         vals=', '.join(type_str, Data.vals_list_dict_float[size]),
-        dest_type1=dest_types[0],
-        dest_type2=dest_types[1])
+        dest_type=dest_type)
 
     string = wrap_with_kernel(
-        dest_types[0], kernel_name,
+        dest_type, kernel_name,
         'convert() as() test for cl::sycl::vec<' + type_str + ', ' + str(size) + '> to '+ dest,
         test_string)
     return wrap_with_test_func(TEST_NAME_OP, type_str, string, str(size))
 
-def make_optional_tests(type_str, input_file, output_file, dest, dest_types):
+def make_optional_tests(type_str, input_file, output_file, dest, dest_type):
     api_checks = ''
     func_calls = ''
     TEST_NAME_OP = TEST_NAME + '_as_convert_to_' + dest
     for size in Data.standard_sizes:
-        api_checks += gen_optional_checks(type_str, size, dest, dest_types, TEST_NAME_OP)
+        api_checks += gen_optional_checks(type_str, size, dest, dest_type, TEST_NAME_OP)
         func_calls += make_func_call(TEST_NAME_OP, type_str, str(size))
     write_source_file(api_checks, func_calls, TEST_NAME_OP, input_file,
                     output_file.replace('.cpp','_as_convert_to_'+dest+'.cpp'), type_str)
@@ -118,13 +112,13 @@ def make_tests(type_str, input_file, output_file, target_enable):
     write_source_file(api_checks, func_calls, TEST_NAME, input_file,
                       output_file, type_str)
 
-    if '64' in target_enable and  not('double' in type_str):
+    if '64' in target_enable and not('double' in type_str):
         make_optional_tests(type_str, input_file, output_file, 'fp64',
-                            ['double', 'cl::sycl::cl_double'])
+                            'double')
 
     if '16' in target_enable and not('half' in type_str):
         make_optional_tests(type_str, input_file, output_file, 'fp16',
-                            ['cl::sycl::half', 'cl::sycl::cl_half'])
+                            'cl::sycl::half')
 
 
 def main():
diff --git a/tests/vector_constructors/CMakeLists.txt b/tests/vector_constructors/CMakeLists.txt
index 1901611e3..4604ec472 100644
--- a/tests/vector_constructors/CMakeLists.txt
+++ b/tests/vector_constructors/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 get_no_vec_alias_type(TYPE_LIST)
 get_fixed_width_type(TYPE_LIST)
 
diff --git a/tests/vector_constructors/generate_vector_constructors.py b/tests/vector_constructors/generate_vector_constructors.py
index 044387c43..e03616e4a 100755
--- a/tests/vector_constructors/generate_vector_constructors.py
+++ b/tests/vector_constructors/generate_vector_constructors.py
@@ -118,19 +118,14 @@ def generate_constructor_tests(type_str, input_file, output_file):
     """Generates a string for each constructor type containing each combination of test
     Constructor types: default, explicit, vec, opencl
     A cross section of variadic constructors are provided by the template"""
-    is_opencl_type = type_str in ReverseData.rev_opencl_type_dict
     test_str = ''
     test_func_str = ''
     func_calls = ''
     vector_sizes = Data.standard_sizes
-    if is_opencl_type:
-        vector_sizes = [2, 3, 4, 8, 16]
     for size in vector_sizes:
         test_str += generate_default(type_str, size)
         test_str += generate_explicit(type_str, size)
         test_str += generate_vec(type_str, size)
-        if is_opencl_type:
-            test_str += generate_opencl(type_str, size)
         test_func_str += wrap_with_test_func(TEST_NAME, type_str,
                                              test_str, str(size))
         test_str = ''
diff --git a/tests/vector_load_store/CMakeLists.txt b/tests/vector_load_store/CMakeLists.txt
index 16a40721e..fd747b558 100644
--- a/tests/vector_load_store/CMakeLists.txt
+++ b/tests/vector_load_store/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 get_no_vec_alias_type(TYPE_LIST)
 get_fixed_width_type(TYPE_LIST)
 
diff --git a/tests/vector_operators/CMakeLists.txt b/tests/vector_operators/CMakeLists.txt
index 67ba227aa..d47e51235 100644
--- a/tests/vector_operators/CMakeLists.txt
+++ b/tests/vector_operators/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 get_no_vec_alias_type(TYPE_LIST)
 get_fixed_width_type(TYPE_LIST)
 
diff --git a/tests/vector_operators/generate_vector_operators.py b/tests/vector_operators/generate_vector_operators.py
index 4e17b00ce..999c565ca 100755
--- a/tests/vector_operators/generate_vector_operators.py
+++ b/tests/vector_operators/generate_vector_operators.py
@@ -1228,24 +1228,14 @@ def generate_operator_tests(type_str, input_file, output_file):
     """"""
     test_func_str = ''
     func_calls = ''
-    is_opencl_type = type_str in ReverseData.rev_opencl_type_dict
     for size in Data.standard_sizes:
         test_str = generate_all_type_test(type_str, size)
         test_func_str += wrap_with_test_func(TEST_NAME + '_ALL_TYPES',
                                              type_str, test_str, str(size))
         func_calls += make_func_call(TEST_NAME + '_ALL_TYPES', type_str,
                                      str(size))
-        if is_opencl_type:
-            test_str = generate_all_types_specific_return_type_test(
-                type_str, size)
-            test_func_str += wrap_with_test_func(
-                TEST_NAME + '_SPECIFIC_RETURN_TYPES', type_str, test_str,
-                str(size))
-            func_calls += make_func_call(TEST_NAME + '_SPECIFIC_RETURN_TYPES',
-                                         type_str, str(size))
         if not type_str in [
-                'float', 'double', 'cl::sycl::half', 'cl::sycl::cl_float',
-                'cl::sycl::cl_double', 'cl::sycl::cl_half'
+                'float', 'double', 'cl::sycl::half'
         ]:
             test_str = generate_non_fp_assignment_test(type_str, size)
             test_func_str += wrap_with_test_func(
diff --git a/tests/vector_swizzle_assignment/CMakeLists.txt b/tests/vector_swizzle_assignment/CMakeLists.txt
index a691ee113..44e3054ab 100644
--- a/tests/vector_swizzle_assignment/CMakeLists.txt
+++ b/tests/vector_swizzle_assignment/CMakeLists.txt
@@ -2,7 +2,6 @@ set(TEST_CASES_LIST "")
 
 set(TYPE_LIST "")
 get_std_type(TYPE_LIST)
-get_opencl_type(TYPE_LIST)
 get_no_vec_alias_type(TYPE_LIST)
 get_fixed_width_type(TYPE_LIST)
 
diff --git a/tests/vector_swizzles/generate_vector_swizzles.py b/tests/vector_swizzles/generate_vector_swizzles.py
index e1c082e73..e7c5ee5d1 100755
--- a/tests/vector_swizzles/generate_vector_swizzles.py
+++ b/tests/vector_swizzles/generate_vector_swizzles.py
@@ -11,7 +11,7 @@
 import argparse
 from string import Template
 sys.path.append('../common/')
-from common_python_vec import (get_standard_and_fixed_width_types, make_swizzles_tests)
+from common_python_vec import (get_types, make_swizzles_tests)
 
 def main():
     argparser = argparse.ArgumentParser(
@@ -24,7 +24,7 @@ def main():
         '-type',
         dest='ty',
         required=True,
-        choices=get_standard_and_fixed_width_types(),
+        choices=get_types(),
         help='Type to generate the test for')
     argparser.add_argument(
         '-o',
diff --git a/tests/vector_swizzles_opencl/CMakeLists.txt b/tests/vector_swizzles_opencl/CMakeLists.txt
deleted file mode 100644
index 548e54035..000000000
--- a/tests/vector_swizzles_opencl/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-set(TEST_CASES_LIST "")
-
-set(TYPE_LIST "")
-get_opencl_type(TYPE_LIST)
-
-half_double_filter(TYPE_LIST)
-
-foreach(TY IN LISTS TYPE_LIST)
-  set(OUT_FILE "vector_swizzles_opencl_${TY}.cpp")
-  STRING(REGEX REPLACE ":" "_" OUT_FILE ${OUT_FILE})
-  STRING(REGEX REPLACE " " "_" OUT_FILE ${OUT_FILE})
-  STRING(REGEX REPLACE "cl__sycl__" "" OUT_FILE ${OUT_FILE})
-  STRING(REGEX REPLACE "std__" "" OUT_FILE ${OUT_FILE})
-
-  # Invoke our generator
-  # the path to the generated cpp file will be added to TEST_CASES_LIST
-  generate_cts_test(TESTS TEST_CASES_LIST
-    GENERATOR "generate_vector_swizzles_opencl.py"
-    OUTPUT ${OUT_FILE}
-    INPUT "../common/vector_swizzles.template"
-    EXTRA_ARGS -type "${TY}")
-endforeach()
-
-add_cts_test(${TEST_CASES_LIST})
diff --git a/tests/vector_swizzles_opencl/generate_vector_swizzles_opencl.py b/tests/vector_swizzles_opencl/generate_vector_swizzles_opencl.py
deleted file mode 100755
index 4927d7985..000000000
--- a/tests/vector_swizzles_opencl/generate_vector_swizzles_opencl.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-# ************************************************************************
-#
-#   SYCL Conformance Test Suite
-#
-#   Copyright:	(c) 2018 by Codeplay Software LTD. All Rights Reserved.
-#
-# ************************************************************************
-
-import sys
-import argparse
-from string import Template
-from itertools import product
-sys.path.append('../common/')
-from common_python_vec import (get_opencl_types, make_swizzles_tests)
-
-def main():
-    argparser = argparse.ArgumentParser(
-        description='Generates vector swizzles opencl test')
-    argparser.add_argument(
-        'template',
-        metavar='<code template path>',
-        help='Path to code template')
-    argparser.add_argument(
-        '-type',
-        dest='ty',
-        required=True,
-        choices=get_opencl_types(),
-        help='Type to generate the test for')
-    argparser.add_argument(
-        '-o',
-        required=True,
-        dest="output",
-        metavar='<out file>',
-        help='CTS test output')
-    args = argparser.parse_args()
-
-    make_swizzles_tests(args.ty, args.template, args.output)
-
-
-if __name__ == '__main__':
-    main()