diff --git a/test_conformance/mem_host_flags/mem_host_image.cpp b/test_conformance/mem_host_flags/mem_host_image.cpp
index f6b94c98..24241f77 100644
--- a/test_conformance/mem_host_flags/mem_host_image.cpp
+++ b/test_conformance/mem_host_flags/mem_host_image.cpp
@@ -1,6 +1,6 @@
 //
 // Copyright (c) 2017 The Khronos Group Inc.
-// 
+//
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -27,338 +27,372 @@
 #include "checker_image_mem_host_write_only.hpp"
 
 //======================================
-static cl_int test_mem_host_read_only_RW_Image(cl_device_id deviceID, cl_context context,
-                                               cl_command_queue queue, cl_bool blocking,
-                                               cl_mem_flags buffer_mem_flag,
-                                               cl_mem_object_type image_type_in,
-                                               size_t array_size, size_t *img_dim)
+static cl_int test_mem_host_read_only_RW_Image(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
 {
-  log_info("%s  ... \n ", __FUNCTION__);
-  cl_int err = CL_SUCCESS;
+    log_info("%s  ... \n ", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  cImage_check_mem_host_read_only< int > checker(deviceID, context, queue);
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
+    cImage_check_mem_host_read_only<int> checker(deviceID, context, queue);
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
 
-  checker.SetupImage();
-  checker.Init_rect();
-  err = checker.verify_RW_Image();
-  test_error(err, __FUNCTION__);
-  clFinish(queue);
-  return err;
+    checker.SetupImage();
+    checker.Init_rect();
+    err = checker.verify_RW_Image();
+    test_error(err, __FUNCTION__);
+    clFinish(queue);
+    return err;
 }
 
-static cl_int test_mem_host_read_only_RW_Image_Mapping(cl_device_id deviceID, cl_context context,
-                                                       cl_command_queue queue, cl_bool blocking,
-                                                       cl_mem_flags buffer_mem_flag,
-                                                       cl_mem_object_type image_type_in,
-                                                       size_t array_size, size_t *img_dim)
+static cl_int test_mem_host_read_only_RW_Image_Mapping(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
 {
-  log_info("%s  ... \n ", __FUNCTION__);
-  cl_int err = CL_SUCCESS;
+    log_info("%s  ... \n ", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  cImage_check_mem_host_read_only< int > checker(deviceID, context, queue);
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
+    cImage_check_mem_host_read_only<int> checker(deviceID, context, queue);
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
 
-  checker.SetupImage();
-  checker.Init_rect();
-  err = checker.verify_RW_Image_Mapping();
-  test_error(err, __FUNCTION__);
-  clFinish(queue);
-  return err;
+    checker.SetupImage();
+    checker.Init_rect();
+    err = checker.verify_RW_Image_Mapping();
+    test_error(err, __FUNCTION__);
+    clFinish(queue);
+    return err;
 }
 
 int test_mem_host_read_only_image(cl_device_id deviceID, cl_context context,
                                   cl_command_queue queue, int num_elements)
 {
-  cl_mem_flags buffer_mem_flags[2] = { CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
-    CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY };
+    cl_mem_flags buffer_mem_flags[2] = {
+        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
+        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY
+    };
 
-  cl_int err = CL_SUCCESS;
+    cl_int err = CL_SUCCESS;
 
-  cl_bool image_support;
-  err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL);
-  if (err) {
-    test_error(err, __FUNCTION__);
-    return err;
-  }
-  if (!image_support) {
-    log_info("Images are not supported by the device, skipping test...\n");
-    return 0;
-  }
-
-
-  cl_mem_object_type img_type[5] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY};
-
-  size_t img_dims[5][3] = {{200, 1, 1}, {200, 80, 1}, {200, 80, 5}, {200, 1, 1}, {200, 80, 10}}; // in elements
-
-  size_t array_size[5] = {1, 10, 1, 10, 1};
-
-  cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
-  for (int flag=0; flag<2; flag++)
-    for (int i=0; i<2; i++) // blocking
+    cl_bool image_support;
+    err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
+                          sizeof image_support, &image_support, NULL);
+    if (err)
     {
-      for(int p=0; p<3; p++)
-      {
-        err = test_mem_host_read_only_RW_Image(deviceID, context, queue, blocking[i],
-                                               buffer_mem_flags[flag], img_type[p],
-                                               array_size[p], img_dims[p]);
-
         test_error(err, __FUNCTION__);
-
-        err = test_mem_host_read_only_RW_Image_Mapping(deviceID, context, queue, blocking[i],
-                                                       buffer_mem_flags[flag], img_type[p],
-                                                       array_size[p], img_dims[p]);
-
-        test_error(err, __FUNCTION__);
-      }
+        return err;
+    }
+    if (!image_support)
+    {
+        log_info("Images are not supported by the device, skipping test...\n");
+        return 0;
     }
 
-  return err;
+
+    cl_mem_object_type img_type[5] = {
+        CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
+        CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
+    };
+
+    size_t img_dims[5][3] = { { 200, 1, 1 },
+                              { 200, 80, 1 },
+                              { 200, 80, 5 },
+                              { 200, 1, 1 },
+                              { 200, 80, 10 } }; // in elements
+
+    size_t array_size[5] = { 1, 10, 1, 10, 1 };
+
+    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
+    for (int flag = 0; flag < 2; flag++)
+        for (int i = 0; i < 2; i++) // blocking
+        {
+            for (int p = 0; p < 3; p++)
+            {
+                err = test_mem_host_read_only_RW_Image(
+                    deviceID, context, queue, blocking[i],
+                    buffer_mem_flags[flag], img_type[p], array_size[p],
+                    img_dims[p]);
+
+                test_error(err, __FUNCTION__);
+
+                err = test_mem_host_read_only_RW_Image_Mapping(
+                    deviceID, context, queue, blocking[i],
+                    buffer_mem_flags[flag], img_type[p], array_size[p],
+                    img_dims[p]);
+
+                test_error(err, __FUNCTION__);
+            }
+        }
+
+    return err;
 }
 
 //----------------------------
-static cl_int test_MEM_HOST_WRIE_ONLY_Image_RW (cl_device_id deviceID, cl_context context,
-                                                cl_command_queue queue, cl_bool blocking,
-                                                cl_mem_flags buffer_mem_flag,
-                                                cl_mem_object_type image_type_in,
-                                                size_t array_size, size_t *img_dim)
+static cl_int test_MEM_HOST_WRIE_ONLY_Image_RW(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
 {
-  log_info(" %s  ... \n ", __FUNCTION__);
-  cl_int err = CL_SUCCESS;
+    log_info(" %s  ... \n ", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  cImage_check_mem_host_write_only< int > checker(deviceID, context, queue);
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
+    cImage_check_mem_host_write_only<int> checker(deviceID, context, queue);
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
 
-  checker.SetupImage();
-  checker.Init_rect();
-  checker.Setup_Test_Environment();
+    checker.SetupImage();
+    checker.Init_rect();
+    checker.Setup_Test_Environment();
 
-  err = checker.verify_RW_Image();
-  clFinish(queue);
-  test_error(err, __FUNCTION__);
+    err = checker.verify_RW_Image();
+    clFinish(queue);
+    test_error(err, __FUNCTION__);
 
-  return err;
+    return err;
 }
 
-static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(cl_device_id deviceID, cl_context context,
-                                                        cl_command_queue queue, cl_bool blocking,
-                                                        cl_mem_flags buffer_mem_flag,
-                                                        cl_mem_object_type image_type_in,
-                                                        size_t array_size, size_t *img_dim)
+static cl_int test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
 {
-  log_info("%s  ... \n ", __FUNCTION__);
-  cl_int err = CL_SUCCESS;
+    log_info("%s  ... \n ", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  cImage_check_mem_host_write_only< int > checker(deviceID, context, queue);
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
+    cImage_check_mem_host_write_only<int> checker(deviceID, context, queue);
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
 
-  checker.SetupImage();
-  checker.Init_rect();
-  checker.Setup_Test_Environment();
+    checker.SetupImage();
+    checker.Init_rect();
+    checker.Setup_Test_Environment();
 
-  err = checker.verify_RW_Image_Mapping();
-  clFinish(queue);
-  test_error(err, __FUNCTION__);
+    err = checker.verify_RW_Image_Mapping();
+    clFinish(queue);
+    test_error(err, __FUNCTION__);
 
-  return err;
+    return err;
 }
 
 int test_mem_host_write_only_image(cl_device_id deviceID, cl_context context,
                                    cl_command_queue queue, int num_elements)
 {
-  cl_mem_flags buffer_mem_flags[2] = { CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
-    CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY };
+    cl_mem_flags buffer_mem_flags[2] = {
+        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
+        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY
+    };
 
-  cl_int err = CL_SUCCESS;
+    cl_int err = CL_SUCCESS;
 
-  cl_bool image_support;
-  err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL);
-  if (err) {
-    test_error(err, __FUNCTION__);
-    return err;
-  }
-  if (!image_support) {
-    log_info("Images are not supported by the device, skipping test...\n");
-    return 0;
-  }
-
-  cl_mem_object_type img_type[5]= {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
-    CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY};
-
-  size_t img_dims[5][3]= {{200, 1, 1}, {200, 80, 1}, {200, 80, 5}, {200, 1, 1}, {200, 80, 1}  }; // in elements
-
-  size_t array_size[5] = {1, 10, 1, 10, 1};
-
-  cl_bool blocking[2] = {CL_TRUE, CL_FALSE};
-  for (int k=0; k<2; k++)
-    for (int i=0; i<2; i++) // blocking
+    cl_bool image_support;
+    err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
+                          sizeof image_support, &image_support, NULL);
+    if (err)
     {
-      for (int p=0; p<3; p++)
-      {
-        err = test_MEM_HOST_WRIE_ONLY_Image_RW(deviceID, context, queue, blocking[i],
-                                               buffer_mem_flags[k],  img_type[p], array_size[p], img_dims[p]);
         test_error(err, __FUNCTION__);
-
-        err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(deviceID, context, queue, blocking[i],
-                                                        buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]);
-        test_error(err, __FUNCTION__);
-      }
+        return err;
+    }
+    if (!image_support)
+    {
+        log_info("Images are not supported by the device, skipping test...\n");
+        return 0;
     }
 
-  return err;
+    cl_mem_object_type img_type[5] = {
+        CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
+        CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
+    };
+
+    size_t img_dims[5][3] = { { 200, 1, 1 },
+                              { 200, 80, 1 },
+                              { 200, 80, 5 },
+                              { 200, 1, 1 },
+                              { 200, 80, 1 } }; // in elements
+
+    size_t array_size[5] = { 1, 10, 1, 10, 1 };
+
+    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
+    for (int k = 0; k < 2; k++)
+        for (int i = 0; i < 2; i++) // blocking
+        {
+            for (int p = 0; p < 3; p++)
+            {
+                err = test_MEM_HOST_WRIE_ONLY_Image_RW(
+                    deviceID, context, queue, blocking[i], buffer_mem_flags[k],
+                    img_type[p], array_size[p], img_dims[p]);
+                test_error(err, __FUNCTION__);
+
+                err = test_MEM_HOST_WRITE_ONLY_Image_RW_Mapping(
+                    deviceID, context, queue, blocking[i], buffer_mem_flags[k],
+                    img_type[p], array_size[p], img_dims[p]);
+                test_error(err, __FUNCTION__);
+            }
+        }
+
+    return err;
 }
 
 //--------
 
-static cl_int test_mem_host_no_access_Image_RW(cl_device_id deviceID, cl_context context,
-                                               cl_command_queue queue, cl_bool blocking,
-                                               cl_mem_flags buffer_mem_flag,
-                                               cl_mem_object_type image_type_in,
-                                               size_t array_size, size_t *img_dim)
+static cl_int test_mem_host_no_access_Image_RW(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
 {
-  log_info("%s  ... \n", __FUNCTION__);
-  cl_int err = CL_SUCCESS;
+    log_info("%s  ... \n", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  cImage_check_mem_host_no_access< int > checker(deviceID, context, queue);
+    cImage_check_mem_host_no_access<int> checker(deviceID, context, queue);
 
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
 
-  checker.SetupImage();
-  checker.Init_rect();
-  checker.Setup_Test_Environment();
-  err = checker.verify_RW_Image();
-  test_error(err, __FUNCTION__);
-  clFinish(queue);
-  return err;
-}
-
-static cl_int test_mem_host_no_access_Image_RW_Mapping(cl_device_id deviceID, cl_context context,
-                                                       cl_command_queue queue, cl_bool blocking,
-                                                       cl_mem_flags buffer_mem_flag,
-                                                       cl_mem_object_type image_type_in,
-                                                       size_t array_size, size_t *img_dim)
-{
-  log_info("%s  ... \n ", __FUNCTION__);
-  cl_int err =CL_SUCCESS;
-
-  cImage_check_mem_host_no_access< int > checker(deviceID, context, queue);
-
-  checker.m_blocking = blocking;
-  checker.buffer_mem_flag = buffer_mem_flag;
-
-  checker.m_cl_Image_desc.image_type = image_type_in;
-  checker.m_cl_Image_desc.image_width = img_dim[0];
-  checker.m_cl_Image_desc.image_height = img_dim[1];
-  checker.m_cl_Image_desc.image_depth = img_dim[2];
-  checker.m_cl_Image_desc.image_array_size = array_size;
-  checker.m_cl_Image_desc.image_row_pitch = 0;
-  checker.m_cl_Image_desc.image_slice_pitch = 0;
-  checker.m_cl_Image_desc.num_mip_levels = 0;
-  checker.m_cl_Image_desc.num_samples = 0;
-
-  checker.SetupImage();
-  checker.Init_rect();
-  checker.Setup_Test_Environment();
-  err = checker.verify_RW_Image_Mapping();
-  test_error(err, __FUNCTION__);
-  clFinish(queue);
-  return err;
-}
-
-int  test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
-                                   cl_command_queue queue, int num_elements)
-{
-  cl_mem_flags buffer_mem_flags[2] = {CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
-    CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS };
-
-  cl_int err = CL_SUCCESS;
-
-  cl_bool image_support;
-  err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT, sizeof image_support, &image_support, NULL);
-  if (err) {
+    checker.SetupImage();
+    checker.Init_rect();
+    checker.Setup_Test_Environment();
+    err = checker.verify_RW_Image();
     test_error(err, __FUNCTION__);
+    clFinish(queue);
     return err;
-  }
-  if (!image_support) {
-    log_info("Images are not supported by the device, skipping test...\n");
-    return 0;
-  }
+}
 
-  cl_mem_object_type img_type[5] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
-    CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY};
+static cl_int test_mem_host_no_access_Image_RW_Mapping(
+    cl_device_id deviceID, cl_context context, cl_command_queue queue,
+    cl_bool blocking, cl_mem_flags buffer_mem_flag,
+    cl_mem_object_type image_type_in, size_t array_size, size_t *img_dim)
+{
+    log_info("%s  ... \n ", __FUNCTION__);
+    cl_int err = CL_SUCCESS;
 
-  size_t img_dims[5][3]= {{200, 1, 1}, {200, 80, 1}, {100, 80, 5}, {200, 1, 1}, {200, 80, 1}}; // in elements
+    cImage_check_mem_host_no_access<int> checker(deviceID, context, queue);
 
-  size_t array_size [5] = {1, 1, 1, 10, 10};
+    checker.m_blocking = blocking;
+    checker.buffer_mem_flag = buffer_mem_flag;
 
-  cl_bool blocking[2] = { CL_TRUE, CL_FALSE};
-  for (int k=0; k<2; k++)
-    for (int i=0; i<2; i++) // blocking
+    checker.m_cl_Image_desc.image_type = image_type_in;
+    checker.m_cl_Image_desc.image_width = img_dim[0];
+    checker.m_cl_Image_desc.image_height = img_dim[1];
+    checker.m_cl_Image_desc.image_depth = img_dim[2];
+    checker.m_cl_Image_desc.image_array_size = array_size;
+    checker.m_cl_Image_desc.image_row_pitch = 0;
+    checker.m_cl_Image_desc.image_slice_pitch = 0;
+    checker.m_cl_Image_desc.num_mip_levels = 0;
+    checker.m_cl_Image_desc.num_samples = 0;
+
+    checker.SetupImage();
+    checker.Init_rect();
+    checker.Setup_Test_Environment();
+    err = checker.verify_RW_Image_Mapping();
+    test_error(err, __FUNCTION__);
+    clFinish(queue);
+    return err;
+}
+
+int test_mem_host_no_access_image(cl_device_id deviceID, cl_context context,
+                                  cl_command_queue queue, int num_elements)
+{
+    cl_mem_flags buffer_mem_flags[2] = {
+        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
+        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS
+    };
+
+    cl_int err = CL_SUCCESS;
+
+    cl_bool image_support;
+    err = clGetDeviceInfo(deviceID, CL_DEVICE_IMAGE_SUPPORT,
+                          sizeof image_support, &image_support, NULL);
+    if (err)
     {
-      for (int p =0; p<3; p++)
-      {
-        err += test_mem_host_no_access_Image_RW (deviceID, context, queue, blocking[i],
-                                                buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]);
-
-        err +=  test_mem_host_no_access_Image_RW_Mapping(deviceID, context, queue, blocking[i],
-                                                       buffer_mem_flags[k], img_type[p], array_size[p], img_dims[p]);
-      }
+        test_error(err, __FUNCTION__);
+        return err;
+    }
+    if (!image_support)
+    {
+        log_info("Images are not supported by the device, skipping test...\n");
+        return 0;
     }
 
-  return  err;
+    cl_mem_object_type img_type[5] = {
+        CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D,
+        CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D_ARRAY
+    };
+
+    size_t img_dims[5][3] = { { 200, 1, 1 },
+                              { 200, 80, 1 },
+                              { 100, 80, 5 },
+                              { 200, 1, 1 },
+                              { 200, 80, 1 } }; // in elements
+
+    size_t array_size[5] = { 1, 1, 1, 10, 10 };
+
+    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
+    for (int k = 0; k < 2; k++)
+        for (int i = 0; i < 2; i++) // blocking
+        {
+            for (int p = 0; p < 3; p++)
+            {
+                err += test_mem_host_no_access_Image_RW(
+                    deviceID, context, queue, blocking[i], buffer_mem_flags[k],
+                    img_type[p], array_size[p], img_dims[p]);
+
+                err += test_mem_host_no_access_Image_RW_Mapping(
+                    deviceID, context, queue, blocking[i], buffer_mem_flags[k],
+                    img_type[p], array_size[p], img_dims[p]);
+            }
+        }
+
+    return err;
 }