diff --git a/test_conformance/api/test_api_min_max.cpp b/test_conformance/api/test_api_min_max.cpp
index cf3d26e2..9ac4aae3 100644
--- a/test_conformance/api/test_api_min_max.cpp
+++ b/test_conformance/api/test_api_min_max.cpp
@@ -136,7 +136,8 @@ int test_min_max_thread_dimensions(cl_device_id deviceID, cl_context context, cl
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * 100, NULL, &error );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * 100, NULL, &error);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating test array failed!\n");
@@ -321,7 +322,8 @@ int test_min_max_read_image_args(cl_device_id deviceID, cl_context context, cl_c
     test_error( error, "Failed to create the program and kernel.");
     free( programSrc );
 
-    result = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_float), NULL, &error);
+    result = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_float), NULL,
+                            &error);
     test_error( error, "clCreateBufer failed");
 
     /* Create some I/O streams */
@@ -1097,7 +1099,8 @@ int test_min_max_parameter_size(cl_device_id deviceID, cl_context context, cl_co
         /* Try to set a large argument to the kernel */
         retVal = 0;
 
-        mem = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_long), NULL, &error);
+        mem = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_long), NULL,
+                             &error);
         test_error(error, "clCreateBuffer failed");
 
         for (i=0; i<(int)numberOfIntParametersToTry; i++) {
@@ -1251,7 +1254,8 @@ int test_min_max_samplers(cl_device_id deviceID, cl_context context, cl_command_
     clMemWrapper image = create_image_2d( context, CL_MEM_READ_WRITE, &format, 16, 16, 0, NULL, &error );
     test_error( error, "Unable to create a test image" );
 
-    clMemWrapper stream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), 16, NULL, &error );
+    clMemWrapper stream =
+        clCreateBuffer(context, CL_MEM_READ_WRITE, 16, NULL, &error);
     test_error( error, "Unable to create test buffer" );
 
     error = clSetKernelArg( kernel, 0, sizeof( cl_mem ), &image );
@@ -1352,9 +1356,11 @@ int test_min_max_constant_buffer_size(cl_device_id deviceID, cl_context context,
             constantData[i] = (int)genrand_int32(d);
 
         clMemWrapper streams[3];
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeToAllocate, constantData, &error);
+        streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                    sizeToAllocate, constantData, &error);
         test_error( error, "Creating test array failed" );
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeToAllocate, NULL, &error);
+        streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeToAllocate,
+                                    NULL, &error);
         test_error( error, "Creating test array failed" );
 
 
@@ -1518,7 +1524,8 @@ int test_min_max_constant_args(cl_device_id deviceID, cl_context context, cl_com
     streams = new clMemWrapper[ maxArgs + 1 ];
     for( i = 0; i < maxArgs + 1; i++ )
     {
-        streams[i] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), individualBufferSize, NULL, &error);
+        streams[i] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    individualBufferSize, NULL, &error);
         test_error( error, "Creating test array failed" );
     }
 
@@ -1726,9 +1733,11 @@ int test_min_max_local_mem_size(cl_device_id deviceID, cl_context context, cl_co
         localData[i] = (int)genrand_int32(d);
     free_mtdata(d); d = NULL;
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeToAllocate, localData, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR, sizeToAllocate,
+                                localData, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeToAllocate, NULL, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeToAllocate,
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
 
 
diff --git a/test_conformance/api/test_create_context_from_type.cpp b/test_conformance/api/test_create_context_from_type.cpp
index bbc2c866..b67041ff 100644
--- a/test_conformance/api/test_create_context_from_type.cpp
+++ b/test_conformance/api/test_create_context_from_type.cpp
@@ -80,9 +80,11 @@ int test_create_context_from_type(cl_device_id deviceID, cl_context context, cl_
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer(context_to_test, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 10, NULL, &error);
+    streams[0] = clCreateBuffer(context_to_test, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 10, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context_to_test, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * 10, NULL, &error);
+    streams[1] = clCreateBuffer(context_to_test, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * 10, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     /* Write some test data */
diff --git a/test_conformance/api/test_create_kernels.cpp b/test_conformance/api/test_create_kernels.cpp
index 59f7f0aa..79e01fdb 100644
--- a/test_conformance/api/test_create_kernels.cpp
+++ b/test_conformance/api/test_create_kernels.cpp
@@ -456,7 +456,8 @@ int test_enqueue_task(cl_device_id deviceID, cl_context context, cl_command_queu
 
     // Create args
     count = 100;
-    output = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( cl_int ) * count, NULL, &error );
+    output = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int) * count,
+                            NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     error = clSetKernelArg( kernel, 0, sizeof( cl_mem ), &output );
diff --git a/test_conformance/api/test_kernel_arg_changes.cpp b/test_conformance/api/test_kernel_arg_changes.cpp
index d85ae99b..eb798a90 100644
--- a/test_conformance/api/test_kernel_arg_changes.cpp
+++ b/test_conformance/api/test_kernel_arg_changes.cpp
@@ -74,14 +74,16 @@ int test_kernel_arg_changes(cl_device_id device, cl_context context, cl_command_
         sizes[ i ][ 0 ] = genrand_int32(seed) % (maxWidth/32) + 1;
         sizes[ i ][ 1 ] = genrand_int32(seed) % (maxHeight/32) + 1;
 
-        images[ i ] = create_image_2d( context, (cl_mem_flags)(CL_MEM_READ_ONLY),
-                                     &imageFormat, sizes[ i ][ 0], sizes[ i ][ 1 ], 0, NULL, &error );
+        images[i] = create_image_2d(context, CL_MEM_READ_ONLY, &imageFormat,
+                                    sizes[i][0], sizes[i][1], 0, NULL, &error);
         if( images[i] == NULL )
         {
             log_error("Failed to create image %d of size %d x %d (%s).\n", i, (int)sizes[i][0], (int)sizes[i][1], IGetErrorString( error ));
             return -1;
         }
-        results[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof( cl_int ) * threads[0] * 2, NULL, &error );
+        results[i] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_int) * threads[0] * 2, NULL, &error);
         if( results[i] == NULL)
         {
             log_error("Failed to create array %d of size %d.\n", i, (int)threads[0]*2);
diff --git a/test_conformance/api/test_kernel_arg_multi_setup.cpp b/test_conformance/api/test_kernel_arg_multi_setup.cpp
index 92c039e1..de3dc15e 100644
--- a/test_conformance/api/test_kernel_arg_multi_setup.cpp
+++ b/test_conformance/api/test_kernel_arg_multi_setup.cpp
@@ -66,24 +66,39 @@ int test_multi_arg_set(cl_device_id device, cl_context context, cl_command_queue
 
     // Create input streams
     initData[ 0 ] = create_random_data( vec1Type, d, (unsigned int)threads[ 0 ] * vec1Size );
-    streams[ 0 ] = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), get_explicit_type_size( vec1Type ) * threads[0] * vec1Size, initData[ 0 ], &error );
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       get_explicit_type_size(vec1Type) * threads[0] * vec1Size,
+                       initData[0], &error);
     test_error( error, "Unable to create testing stream" );
 
     initData[ 1 ] = create_random_data( vec2Type, d, (unsigned int)threads[ 0 ] * vec2Size );
-    streams[ 1 ] = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), get_explicit_type_size( vec2Type ) * threads[0] * vec2Size, initData[ 1 ], &error );
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       get_explicit_type_size(vec2Type) * threads[0] * vec2Size,
+                       initData[1], &error);
     test_error( error, "Unable to create testing stream" );
 
     initData[ 2 ] = create_random_data( vec3Type, d, (unsigned int)threads[ 0 ] * vec3Size );
-    streams[ 2 ] = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), get_explicit_type_size( vec3Type ) * threads[0] * vec3Size, initData[ 2 ], &error );
+    streams[2] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       get_explicit_type_size(vec3Type) * threads[0] * vec3Size,
+                       initData[2], &error);
     test_error( error, "Unable to create testing stream" );
 
-    streams[ 3 ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( vec1Type ) * threads[0] * vec1Size, NULL, &error );
+    streams[3] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        get_explicit_type_size(vec1Type) * threads[0] * vec1Size, NULL, &error);
     test_error( error, "Unable to create testing stream" );
 
-    streams[ 4 ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( vec2Type ) * threads[0] * vec2Size, NULL, &error );
+    streams[4] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        get_explicit_type_size(vec2Type) * threads[0] * vec2Size, NULL, &error);
     test_error( error, "Unable to create testing stream" );
 
-    streams[ 5 ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( vec3Type ) * threads[0] * vec3Size, NULL, &error );
+    streams[5] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        get_explicit_type_size(vec3Type) * threads[0] * vec3Size, NULL, &error);
     test_error( error, "Unable to create testing stream" );
 
     // Set the arguments
diff --git a/test_conformance/api/test_kernels.cpp b/test_conformance/api/test_kernels.cpp
index 993a72fb..d25410ba 100644
--- a/test_conformance/api/test_kernels.cpp
+++ b/test_conformance/api/test_kernels.cpp
@@ -192,10 +192,10 @@ int test_execute_kernel_local_sizes(cl_device_id deviceID, cl_context context, c
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_float) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_int) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
 
@@ -323,10 +323,10 @@ int test_set_kernel_arg_by_index(cl_device_id deviceID, cl_context context, cl_c
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_float) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_int) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
 
@@ -412,15 +412,15 @@ int test_set_kernel_arg_constant(cl_device_id deviceID, cl_context context, cl_c
     }
     free_mtdata(d); d = NULL;
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
                                 sizeof(cl_int) * num_elements,
                                 randomTestDataA.data(), &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
+    streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
                                 sizeof(cl_int) * num_elements,
                                 randomTestDataB.data(), &error);
     test_error( error, "Creating test array failed" );
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_int) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
 
@@ -496,11 +496,11 @@ int test_set_kernel_arg_struct_array(cl_device_id deviceID, cl_context context,
     }
     free_mtdata(d); d = NULL;
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
                                 sizeof(image_pair_t) * num_elements,
                                 (void *)image_pair.data(), &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_int) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
 
@@ -593,11 +593,11 @@ int test_kernel_global_constant(cl_device_id deviceID, cl_context context, cl_co
     }
     free_mtdata(d); d = NULL;
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
                                 sizeof(cl_int) * num_elements,
                                 randomTestDataA.data(), &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_int) * num_elements, NULL, &error);
     test_error( error, "Creating test array failed" );
 
diff --git a/test_conformance/api/test_mem_object_properties_queries.cpp b/test_conformance/api/test_mem_object_properties_queries.cpp
index 2360d83e..55300a62 100644
--- a/test_conformance/api/test_mem_object_properties_queries.cpp
+++ b/test_conformance/api/test_mem_object_properties_queries.cpp
@@ -208,12 +208,12 @@ static int run_test_query_properties(cl_context context, cl_command_queue queue,
     free_mtdata(init_generator);
     init_generator = NULL;
 
-    flags = (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR);
+    flags = CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR;
     error = create_object_and_check_properties(context, obj_src, test_case,
                                                flags, src_data, size_x, size_y);
     test_error(error, "create_object_and_check_properties obj_src failed.");
 
-    flags = (cl_mem_flags)(CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR);
+    flags = CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR;
     error = create_object_and_check_properties(context, obj_dst, test_case,
                                                flags, dst_data, size_x, size_y);
     test_error(error, "create_object_and_check_properties obj_dst failed.");
diff --git a/test_conformance/api/test_retain_program.cpp b/test_conformance/api/test_retain_program.cpp
index a85bc704..aa9c8b36 100644
--- a/test_conformance/api/test_retain_program.cpp
+++ b/test_conformance/api/test_retain_program.cpp
@@ -68,9 +68,11 @@ int test_release_during_execute( cl_device_id deviceID, cl_context context, cl_c
         return -1;
     }
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 10, NULL, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 10, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * 10, NULL, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int) * 10,
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
 
     /* Set the arguments */
diff --git a/test_conformance/atomics/test_atomics.cpp b/test_conformance/atomics/test_atomics.cpp
index 24bf974a..5f4c0943 100644
--- a/test_conformance/atomics/test_atomics.cpp
+++ b/test_conformance/atomics/test_atomics.cpp
@@ -243,13 +243,17 @@ int test_atomic_function(cl_device_id deviceID, cl_context context, cl_command_q
     for( size_t i = 0; i < numDestItems; i++ )
         memcpy( destItems + i * typeSize, startValue, typeSize );
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), typeSize * numDestItems, destItems, NULL);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                typeSize * numDestItems, destItems, NULL);
     if (!streams[0])
     {
         log_error("ERROR: Creating output array failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(( startRefValues != NULL ? CL_MEM_COPY_HOST_PTR : CL_MEM_READ_WRITE )), typeSize * threadSize, startRefValues, NULL);
+    streams[1] = clCreateBuffer(
+        context,
+        ((startRefValues != NULL ? CL_MEM_COPY_HOST_PTR : CL_MEM_READ_WRITE)),
+        typeSize * threadSize, startRefValues, NULL);
     if (!streams[1])
     {
         log_error("ERROR: Creating reference array failed!\n");
diff --git a/test_conformance/atomics/test_indexed_cases.cpp b/test_conformance/atomics/test_indexed_cases.cpp
index 9a27d076..b85e3d24 100644
--- a/test_conformance/atomics/test_indexed_cases.cpp
+++ b/test_conformance/atomics/test_indexed_cases.cpp
@@ -64,12 +64,12 @@ int test_atomic_add_index(cl_device_id deviceID, cl_context context, cl_command_
              (int)numGlobalThreads, (int)numLocalThreads);
 
     // Create the counter that will keep track of where each thread writes.
-    counter = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-                                   sizeof(cl_int) * 1, NULL, NULL);
+    counter = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int) * 1,
+                             NULL, NULL);
     // Create the counters that will hold the results of each thread writing
     // its ID into a (hopefully) unique location.
-    counters = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-                                    sizeof(cl_int) * numGlobalThreads, NULL, NULL);
+    counters = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_int) * numGlobalThreads, NULL, NULL);
 
     // Reset all those locations to -1 to indciate they have not been used.
     cl_int *values = (cl_int*) malloc(sizeof(cl_int)*numGlobalThreads);
@@ -175,12 +175,15 @@ int add_index_bin_test(size_t *global_threads, cl_command_queue queue, cl_contex
              (int)global_threads[0], (int)local_threads[0]);
 
     // Allocate our storage
-    cl_mem bin_counters = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-                                        sizeof(cl_int) * number_of_bins, NULL, NULL);
-    cl_mem bins = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-                                sizeof(cl_int) * number_of_bins*max_counts_per_bin, NULL, NULL);
-    cl_mem bin_assignments = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_ONLY),
-                                           sizeof(cl_int) * number_of_items, NULL, NULL);
+    cl_mem bin_counters =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * number_of_bins, NULL, NULL);
+    cl_mem bins = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        sizeof(cl_int) * number_of_bins * max_counts_per_bin, NULL, NULL);
+    cl_mem bin_assignments =
+        clCreateBuffer(context, CL_MEM_READ_ONLY,
+                       sizeof(cl_int) * number_of_items, NULL, NULL);
 
     if (bin_counters == NULL) {
         log_error("add_index_bin_test FAILED to allocate bin_counters.\n");
diff --git a/test_conformance/basic/test_arraycopy.cpp b/test_conformance/basic/test_arraycopy.cpp
index e0cb565f..5a352869 100644
--- a/test_conformance/basic/test_arraycopy.cpp
+++ b/test_conformance/basic/test_arraycopy.cpp
@@ -51,7 +51,8 @@ test_arraycopy(cl_device_id device, cl_context context, cl_command_queue queue,
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
 
     // results
-    results = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, &err);
+    results = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                             sizeof(cl_uint) * num_elements, NULL, &err);
     test_error(err, "clCreateBuffer failed");
 
 /*****************************************************************************************************************************************/
@@ -64,7 +65,9 @@ test_arraycopy(cl_device_id device, cl_context context, cl_command_queue queue,
         input_ptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
 
     // client backing
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), sizeof(cl_uint) * num_elements, input_ptr, &err);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                       sizeof(cl_uint) * num_elements, input_ptr, &err);
     test_error(err, "clCreateBuffer failed");
 
     delta_offset = num_elements * sizeof(cl_uint) / num_copies;
@@ -103,7 +106,8 @@ test_arraycopy(cl_device_id device, cl_context context, cl_command_queue queue,
         input_ptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
 
     // no backing
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE) , sizeof(cl_uint) * num_elements, NULL, &err);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, &err);
     test_error(err, "clCreateBuffer failed");
 
     for (i=0; i<num_copies; i++)
@@ -146,17 +150,20 @@ test_arraycopy(cl_device_id device, cl_context context, cl_command_queue queue,
     free_mtdata(d); d= NULL;
 
     // client backing
-  streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), sizeof(cl_uint) * num_elements, input_ptr, &err);
-  test_error(err, "clCreateBuffer failed");
+    streams[3] =
+        clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                       sizeof(cl_uint) * num_elements, input_ptr, &err);
+    test_error(err, "clCreateBuffer failed");
 
-  err = create_single_kernel_helper(context, &program, &kernel, 1, &copy_kernel_code, "test_copy" );
-  test_error(err, "create_single_kernel_helper failed");
+    err = create_single_kernel_helper(context, &program, &kernel, 1,
+                                      &copy_kernel_code, "test_copy");
+    test_error(err, "create_single_kernel_helper failed");
 
-  err = clSetKernelArg(kernel, 0, sizeof streams[3], &streams[3]);
-  err |= clSetKernelArg(kernel, 1, sizeof results, &results);
-  test_error(err, "clSetKernelArg failed");
+    err = clSetKernelArg(kernel, 0, sizeof streams[3], &streams[3]);
+    err |= clSetKernelArg(kernel, 1, sizeof results, &results);
+    test_error(err, "clSetKernelArg failed");
 
-  size_t threads[3] = {num_elements, 0, 0};
+    size_t threads[3] = { num_elements, 0, 0 };
 
     err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, NULL, 0, NULL, NULL );
   test_error(err, "clEnqueueNDRangeKernel failed");
diff --git a/test_conformance/basic/test_arrayimagecopy.cpp b/test_conformance/basic/test_arrayimagecopy.cpp
index 5a0263fd..5de5d017 100644
--- a/test_conformance/basic/test_arrayimagecopy.cpp
+++ b/test_conformance/basic/test_arrayimagecopy.cpp
@@ -38,7 +38,8 @@ int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, c
 
   log_info("Testing %s %s\n", GetChannelOrderName(format->image_channel_order), GetChannelTypeName(format->image_channel_data_type));
 
-  image = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), format, img_width, img_height, 0, NULL, &err);
+  image = create_image_2d(context, CL_MEM_READ_WRITE, format, img_width,
+                          img_height, 0, NULL, &err);
   test_error(err, "create_image_2d failed");
 
   err = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &elem_size, NULL);
@@ -46,7 +47,7 @@ int test_arrayimagecopy_single_format(cl_device_id device, cl_context context, c
 
   buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height;
 
-  buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  buffer_size, NULL, &err);
+  buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, NULL, &err);
   test_error(err, "clCreateBuffer failed");
 
   d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_arrayimagecopy3d.cpp b/test_conformance/basic/test_arrayimagecopy3d.cpp
index 0d6a5245..1b08ec92 100644
--- a/test_conformance/basic/test_arrayimagecopy3d.cpp
+++ b/test_conformance/basic/test_arrayimagecopy3d.cpp
@@ -48,7 +48,7 @@ int test_arrayimagecopy3d_single_format(cl_device_id device, cl_context context,
 
   buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height * img_depth;
 
-  buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  buffer_size, NULL, &err);
+  buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, NULL, &err);
   test_error(err, "clCreateBuffer failed");
 
   d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_arrayreadwrite.cpp b/test_conformance/basic/test_arrayreadwrite.cpp
index 68664398..25e8ed99 100644
--- a/test_conformance/basic/test_arrayreadwrite.cpp
+++ b/test_conformance/basic/test_arrayreadwrite.cpp
@@ -43,7 +43,8 @@ test_arrayreadwrite(cl_device_id device, cl_context context, cl_command_queue qu
     for (i=0; i<num_elements; i++)
         inptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, &err);
     test_error(err, "clCreateBuffer failed");
 
     for (i=0; i<num_tries; i++)
diff --git a/test_conformance/basic/test_barrier.cpp b/test_conformance/basic/test_barrier.cpp
index 822b8eb6..d20af14a 100644
--- a/test_conformance/basic/test_barrier.cpp
+++ b/test_conformance/basic/test_barrier.cpp
@@ -108,11 +108,15 @@ test_barrier(cl_device_id device, cl_context context, cl_command_queue queue, in
     input_ptr = (int*)malloc(sizeof(int) * num_elements);
     output_ptr = (int*)malloc(sizeof(int));
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     test_error(err, "clCreateBuffer failed.");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int), NULL, &err);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), NULL, &err);
     test_error(err, "clCreateBuffer failed.");
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * max_threadgroup_size, NULL, &err);
+    streams[2] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * max_threadgroup_size, NULL, &err);
     test_error(err, "clCreateBuffer failed.");
 
     d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_constant.cpp b/test_conformance/basic/test_constant.cpp
index 2bd661a9..ed25c6ef 100644
--- a/test_conformance/basic/test_constant.cpp
+++ b/test_conformance/basic/test_constant.cpp
@@ -140,19 +140,22 @@ test_constant(cl_device_id device, cl_context context, cl_command_queue queue, i
     tmpI = (cl_int*)malloc(sizeof(cl_int) * constant_values);
     tmpF = (cl_float*)malloc(sizeof(cl_float) * constant_values);
     out  = (cl_float*)malloc(sizeof(cl_float) * constant_values);
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * constant_values, NULL, NULL);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * constant_values, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * constant_values, NULL, NULL);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * constant_values, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * constant_values, NULL, NULL);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * constant_values, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/basic/test_enqueued_local_size.cpp b/test_conformance/basic/test_enqueued_local_size.cpp
index e3bce93b..f52162a8 100644
--- a/test_conformance/basic/test_enqueued_local_size.cpp
+++ b/test_conformance/basic/test_enqueued_local_size.cpp
@@ -97,7 +97,8 @@ test_enqueued_local_size(cl_device_id device, cl_context context, cl_command_que
 
     output_ptr   = (int*)malloc(2 * sizeof(int));
 
-    streams = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), 2*sizeof(int), NULL, &err);
+    streams =
+        clCreateBuffer(context, CL_MEM_READ_WRITE, 2 * sizeof(int), NULL, &err);
     test_error( err, "clCreateBuffer failed.");
 
     std::string cl_std = "-cl-std=CL";
diff --git a/test_conformance/basic/test_explicit_s2v.cpp b/test_conformance/basic/test_explicit_s2v.cpp
index 34e7da9c..bf38636a 100644
--- a/test_conformance/basic/test_explicit_s2v.cpp
+++ b/test_conformance/basic/test_explicit_s2v.cpp
@@ -146,9 +146,11 @@ int test_explicit_s2v_function(cl_device_id deviceID, cl_context context, cl_com
         return -1;
     }
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), paramSize * count, inputData, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                paramSize * count, inputData, &error);
     test_error( error, "clCreateBuffer failed");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  destStride * count, NULL, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, destStride * count,
+                                NULL, &error);
     test_error( error, "clCreateBuffer failed");
 
     /* Set the arguments */
diff --git a/test_conformance/basic/test_float2int.cpp b/test_conformance/basic/test_float2int.cpp
index b6af322c..4063a958 100644
--- a/test_conformance/basic/test_float2int.cpp
+++ b/test_conformance/basic/test_float2int.cpp
@@ -69,13 +69,15 @@ test_float2int(cl_device_id device, cl_context context, cl_command_queue queue,
 
     input_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/basic/test_fpmath_float.cpp b/test_conformance/basic/test_fpmath_float.cpp
index 4ed81cc7..6e5deb4b 100644
--- a/test_conformance/basic/test_fpmath_float.cpp
+++ b/test_conformance/basic/test_fpmath_float.cpp
@@ -161,13 +161,13 @@ test_fpmath_float(cl_device_id device, cl_context context, cl_command_queue queu
     input_ptr[2] = (cl_float*)malloc(length);
     output_ptr   = (cl_float*)malloc(length);
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
 
     p = input_ptr[0];
diff --git a/test_conformance/basic/test_fpmath_float2.cpp b/test_conformance/basic/test_fpmath_float2.cpp
index a964f6a4..1881b4be 100644
--- a/test_conformance/basic/test_fpmath_float2.cpp
+++ b/test_conformance/basic/test_fpmath_float2.cpp
@@ -160,13 +160,13 @@ test_fpmath_float2(cl_device_id device, cl_context context, cl_command_queue que
     input_ptr[2] = (cl_float*)malloc(length);
     output_ptr   = (cl_float*)malloc(length);
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
 
     p = input_ptr[0];
diff --git a/test_conformance/basic/test_fpmath_float4.cpp b/test_conformance/basic/test_fpmath_float4.cpp
index 275b4f37..999c8ec5 100644
--- a/test_conformance/basic/test_fpmath_float4.cpp
+++ b/test_conformance/basic/test_fpmath_float4.cpp
@@ -160,13 +160,13 @@ test_fpmath_float4(cl_device_id device, cl_context context, cl_command_queue que
     input_ptr[2] = (cl_float*)malloc(length);
     output_ptr   = (cl_float*)malloc(length);
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
-    streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+    streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
     test_error( err, "clCreateBuffer failed.");
 
     p = input_ptr[0];
diff --git a/test_conformance/basic/test_global_linear_id.cpp b/test_conformance/basic/test_global_linear_id.cpp
index b14b3bbb..046d12a1 100644
--- a/test_conformance/basic/test_global_linear_id.cpp
+++ b/test_conformance/basic/test_global_linear_id.cpp
@@ -70,14 +70,15 @@ test_global_linear_id(cl_device_id device, cl_context context, cl_command_queue
     cl_kernel kernel[2];
 
     int *output_ptr;
-      size_t threads[2];
-      int err;
-      num_elements = (int)sqrt((float)num_elements);
-      int length = num_elements * num_elements;
+    size_t threads[2];
+    int err;
+    num_elements = (int)sqrt((float)num_elements);
+    int length = num_elements * num_elements;
 
-      output_ptr   = (int*)malloc(sizeof(int) * length);
+    output_ptr = (int *)malloc(sizeof(int) * length);
 
-    streams = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length*sizeof(int), NULL, &err);
+    streams = clCreateBuffer(context, CL_MEM_READ_WRITE, length * sizeof(int),
+                             NULL, &err);
     test_error( err, "clCreateBuffer failed.");
 
     err = create_single_kernel_helper(context, &program[0], &kernel[0], 1,
diff --git a/test_conformance/basic/test_global_work_offsets.cpp b/test_conformance/basic/test_global_work_offsets.cpp
index edaca386..39b54b4f 100644
--- a/test_conformance/basic/test_global_work_offsets.cpp
+++ b/test_conformance/basic/test_global_work_offsets.cpp
@@ -138,7 +138,9 @@ int test_global_work_offsets(cl_device_id deviceID, cl_context context, cl_comma
     memset( outputA, 0xff, sizeof( outputA ) );
     for( int i = 0; i < 3; i++ )
     {
-        streams[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR), sizeof(outputA), outputA, &error );
+        streams[i] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
+                           sizeof(outputA), outputA, &error);
         test_error( error, "Unable to create output array" );
     }
 
@@ -228,7 +230,9 @@ int test_get_global_offset(cl_device_id deviceID, cl_context context, cl_command
 
     // Create some output streams, and storage for a single control ID
     memset( outOffsets, 0xff, sizeof( outOffsets ) );
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR), sizeof( outOffsets ), outOffsets, &error );
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
+                       sizeof(outOffsets), outOffsets, &error);
     test_error( error, "Unable to create control ID buffer" );
 
     // Run a few different times
diff --git a/test_conformance/basic/test_hostptr.cpp b/test_conformance/basic/test_hostptr.cpp
index f40cb698..65af5c3c 100644
--- a/test_conformance/basic/test_hostptr.cpp
+++ b/test_conformance/basic/test_hostptr.cpp
@@ -131,39 +131,53 @@ test_hostptr(cl_device_id device, cl_context context, cl_command_queue queue, in
         make_random_data(num_elements, input_ptr[1], d);
 
         // Create host-side input
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), sizeof(cl_float) * num_elements, input_ptr[0], &err);
+        streams[0] =
+            clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                           sizeof(cl_float) * num_elements, input_ptr[0], &err);
         test_error(err, "clCreateBuffer 0 failed");
 
         // Create a copied input
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * num_elements, input_ptr[1], &err);
+        streams[1] =
+            clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                           sizeof(cl_float) * num_elements, input_ptr[1], &err);
         test_error(err, "clCreateBuffer 1 failed");
 
         // Create a host-side output
-        streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), sizeof(cl_float) * num_elements, output_ptr, &err);
+        streams[2] =
+            clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                           sizeof(cl_float) * num_elements, output_ptr, &err);
         test_error(err, "clCreateBuffer 2 failed");
 
         // Create a host-side input
         img_format.image_channel_order = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-        streams[3] = create_image_2d(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), &img_format, img_width, img_height, 0, rgba8_inptr, &err);
+        streams[3] =
+            create_image_2d(context, CL_MEM_USE_HOST_PTR, &img_format,
+                            img_width, img_height, 0, rgba8_inptr, &err);
         test_error(err, "create_image_2d 3 failed");
 
         // Create a copied input
         img_format.image_channel_order = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-        streams[4] = create_image_2d(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), &img_format, img_width, img_height, 0, rgba8_inptr, &err);
+        streams[4] =
+            create_image_2d(context, CL_MEM_COPY_HOST_PTR, &img_format,
+                            img_width, img_height, 0, rgba8_inptr, &err);
         test_error(err, "create_image_2d 4 failed");
 
         // Create a host-side output
         img_format.image_channel_order = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-        streams[5] = create_image_2d(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), &img_format, img_width, img_height, 0, rgba8_outptr, &err);
+        streams[5] =
+            create_image_2d(context, CL_MEM_USE_HOST_PTR, &img_format,
+                            img_width, img_height, 0, rgba8_outptr, &err);
         test_error(err, "create_image_2d 5 failed");
 
         // Create a copied output
         img_format.image_channel_data_type = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-        streams[6] = create_image_2d(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), &img_format, img_width, img_height, 0, rgba8_outptr, &err);
+        streams[6] =
+            create_image_2d(context, CL_MEM_COPY_HOST_PTR, &img_format,
+                            img_width, img_height, 0, rgba8_outptr, &err);
         test_error(err, "create_image_2d 6 failed");
 
         err = create_single_kernel_helper(context, &program, &kernel,1, &hostptr_kernel_code, "test_hostptr" );
diff --git a/test_conformance/basic/test_image_multipass.cpp b/test_conformance/basic/test_image_multipass.cpp
index cd91a136..7f51665c 100644
--- a/test_conformance/basic/test_image_multipass.cpp
+++ b/test_conformance/basic/test_image_multipass.cpp
@@ -172,7 +172,7 @@ test_image_multipass_integer_coord(cl_device_id device, cl_context context, cl_c
         cl_mem_flags        flags;
 
         initial_data = generate_initial_byte_image(img_width, img_height, 4, 0xF0);
-        flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+        flags = CL_MEM_READ_WRITE;
 
         accum_streams[0] = create_image_2d(context, flags, &img_format, img_width, img_height, 0, NULL, NULL);
         if (!accum_streams[0])
@@ -224,7 +224,7 @@ test_image_multipass_integer_coord(cl_device_id device, cl_context context, cl_c
         MTdata              d;
 
         input_streams = (cl_mem*)malloc(sizeof(cl_mem) * num_input_streams);
-        flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+        flags = CL_MEM_READ_WRITE;
 
         int i;
         d = init_genrand( gRandomSeed );
@@ -425,7 +425,7 @@ test_image_multipass_float_coord(cl_device_id device, cl_context context, cl_com
         cl_mem_flags        flags;
 
         initial_data = generate_initial_byte_image(img_width, img_height, 4, 0xF0);
-        flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+        flags = CL_MEM_READ_WRITE;
 
         accum_streams[0] = create_image_2d(context, flags, &img_format, img_width, img_height, 0, NULL, NULL);
         if (!accum_streams[0])
@@ -469,7 +469,7 @@ test_image_multipass_float_coord(cl_device_id device, cl_context context, cl_com
         MTdata              d;
 
         input_streams = (cl_mem*)malloc(sizeof(cl_mem) * num_input_streams);
-        flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+        flags = CL_MEM_READ_WRITE;
 
         int i;
         d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_image_r8.cpp b/test_conformance/basic/test_image_r8.cpp
index 7805c1b5..b633d6ab 100644
--- a/test_conformance/basic/test_image_r8.cpp
+++ b/test_conformance/basic/test_image_r8.cpp
@@ -88,7 +88,9 @@ test_image_r8(cl_device_id device, cl_context context, cl_command_queue queue, i
     img_format.image_channel_data_type = CL_UNSIGNED_INT8;
 
     // early out if this image type is not supported
-    if( ! is_image_format_supported( context, (cl_mem_flags)(CL_MEM_READ_ONLY), CL_MEM_OBJECT_IMAGE2D, &img_format ) ) {
+    if (!is_image_format_supported(context, CL_MEM_READ_ONLY,
+                                   CL_MEM_OBJECT_IMAGE2D, &img_format))
+    {
         log_info("WARNING: Image type not supported; skipping test.\n");
         return 0;
     }
@@ -98,14 +100,17 @@ test_image_r8(cl_device_id device, cl_context context, cl_command_queue queue, i
     free_mtdata(d); d = NULL;
 
     output_ptr = (cl_uchar*)malloc(sizeof(cl_uchar) * img_width * img_height);
-    streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_ONLY), &img_format, img_width, img_height, 0, NULL, NULL);
+    streams[0] = create_image_2d(context, CL_MEM_READ_ONLY, &img_format,
+                                 img_width, img_height, 0, NULL, NULL);
     if (!streams[0])
     {
         log_error("create_image_2d failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uchar) * img_width*img_height, NULL, NULL);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uchar) * img_width * img_height, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/basic/test_imagearraycopy.cpp b/test_conformance/basic/test_imagearraycopy.cpp
index 4240466b..0246d809 100644
--- a/test_conformance/basic/test_imagearraycopy.cpp
+++ b/test_conformance/basic/test_imagearraycopy.cpp
@@ -38,7 +38,8 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, c
 
   log_info("Testing %s %s\n", GetChannelOrderName(format->image_channel_order), GetChannelTypeName(format->image_channel_data_type));
 
-  image = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE), format, img_width, img_height, 0, NULL, &err);
+  image = create_image_2d(context, CL_MEM_READ_WRITE, format, img_width,
+                          img_height, 0, NULL, &err);
   test_error(err, "create_image_2d failed");
 
   err = clGetImageInfo(image, CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &elem_size, NULL);
@@ -46,7 +47,7 @@ int test_imagearraycopy_single_format(cl_device_id device, cl_context context, c
 
   buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height;
 
-  buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  buffer_size, NULL, &err);
+  buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, NULL, &err);
   test_error(err, "clCreateBuffer failed");
 
   d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_imagearraycopy3d.cpp b/test_conformance/basic/test_imagearraycopy3d.cpp
index 91ef1fcc..19dfdbc7 100644
--- a/test_conformance/basic/test_imagearraycopy3d.cpp
+++ b/test_conformance/basic/test_imagearraycopy3d.cpp
@@ -47,7 +47,7 @@ int test_imagearraycopy3d_single_format(cl_device_id device, cl_context context,
 
   buffer_size = sizeof(cl_uchar) * elem_size * img_width * img_height * img_depth;
 
-  buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  buffer_size, NULL, &err);
+  buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, buffer_size, NULL, &err);
   test_error(err, "clCreateBuffer failed");
 
   d = init_genrand( gRandomSeed );
diff --git a/test_conformance/basic/test_imagecopy.cpp b/test_conformance/basic/test_imagecopy.cpp
index e74827d2..bcb9fef9 100644
--- a/test_conformance/basic/test_imagecopy.cpp
+++ b/test_conformance/basic/test_imagecopy.cpp
@@ -132,23 +132,29 @@ test_imagecopy(cl_device_id device, cl_context context, cl_command_queue queue,
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT8;
-    streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT16;
-    streams[2] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[3] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[3] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_FLOAT;
-    streams[4] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[4] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[5] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[5] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     for (i=0; i<3; i++)
diff --git a/test_conformance/basic/test_imagedim.cpp b/test_conformance/basic/test_imagedim.cpp
index 6d8cdb36..6064655f 100644
--- a/test_conformance/basic/test_imagedim.cpp
+++ b/test_conformance/basic/test_imagedim.cpp
@@ -163,7 +163,9 @@ test_imagedim_pow2(cl_device_id device, cl_context context, cl_command_queue que
 
             img_format.image_channel_order = CL_RGBA;
             img_format.image_channel_data_type = CL_UNORM_INT8;
-            streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, NULL);
+            streams[0] =
+                create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                img_width, img_height, 0, NULL, NULL);
             if (!streams[0])
             {
                 log_error("create_image_2d failed.  width = %d, height = %d\n", img_width, img_height);
@@ -174,7 +176,9 @@ test_imagedim_pow2(cl_device_id device, cl_context context, cl_command_queue que
             }
             img_format.image_channel_order = CL_RGBA;
             img_format.image_channel_data_type = CL_UNORM_INT8;
-            streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, NULL);
+            streams[1] =
+                create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                img_width, img_height, 0, NULL, NULL);
             if (!streams[1])
             {
                 log_error("create_image_2d failed.  width = %d, height = %d\n", img_width, img_height);
@@ -404,7 +408,9 @@ test_imagedim_non_pow2(cl_device_id device, cl_context context, cl_command_queue
 
                 img_format.image_channel_order = CL_RGBA;
                 img_format.image_channel_data_type = CL_UNORM_INT8;
-                streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, effective_img_width, effective_img_height, 0, NULL, NULL);
+                streams[0] = create_image_2d(
+                    context, CL_MEM_READ_WRITE, &img_format,
+                    effective_img_width, effective_img_height, 0, NULL, NULL);
                 if (!streams[0])
                 {
                     log_error("create_image_2d failed.  width = %d, height = %d\n", effective_img_width, effective_img_height);
@@ -415,7 +421,9 @@ test_imagedim_non_pow2(cl_device_id device, cl_context context, cl_command_queue
                 }
                 img_format.image_channel_order = CL_RGBA;
                 img_format.image_channel_data_type = CL_UNORM_INT8;
-                streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, effective_img_width, effective_img_height, 0, NULL, NULL);
+                streams[1] = create_image_2d(
+                    context, CL_MEM_READ_WRITE, &img_format,
+                    effective_img_width, effective_img_height, 0, NULL, NULL);
                 if (!streams[1])
                 {
                     log_error("create_image_2d failed.  width = %d, height = %d\n", effective_img_width, effective_img_height);
diff --git a/test_conformance/basic/test_imagenpot.cpp b/test_conformance/basic/test_imagenpot.cpp
index 4713c30e..baa5b2e4 100644
--- a/test_conformance/basic/test_imagenpot.cpp
+++ b/test_conformance/basic/test_imagenpot.cpp
@@ -110,8 +110,8 @@ test_imagenpot(cl_device_id device_id, cl_context context, cl_command_queue queu
 
         img_format.image_channel_order = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-        streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format,
-                                 img_width, img_height, 0, NULL, NULL);
+        streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                     img_width, img_height, 0, NULL, NULL);
         if (!streams[0])
         {
             log_error("create_image_2d failed\n");
@@ -120,8 +120,8 @@ test_imagenpot(cl_device_id device_id, cl_context context, cl_command_queue queu
         }
         img_format.image_channel_order = CL_RGBA;
         img_format.image_channel_data_type = CL_UNORM_INT8;
-    streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format,
-                                 img_width, img_height, 0, NULL, NULL);
+        streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                     img_width, img_height, 0, NULL, NULL);
         if (!streams[1])
         {
             log_error("create_image_2d failed\n");
diff --git a/test_conformance/basic/test_imagerandomcopy.cpp b/test_conformance/basic/test_imagerandomcopy.cpp
index 494d6c25..c3355de3 100644
--- a/test_conformance/basic/test_imagerandomcopy.cpp
+++ b/test_conformance/basic/test_imagerandomcopy.cpp
@@ -146,23 +146,29 @@ test_imagerandomcopy(cl_device_id device, cl_context context, cl_command_queue q
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT8;
-    streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT16;
-    streams[2] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[3] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[3] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_FLOAT;
-    streams[4] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[4] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
-    streams[5] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[5] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     for (i=0; i<3; i++)
diff --git a/test_conformance/basic/test_imagereadwrite.cpp b/test_conformance/basic/test_imagereadwrite.cpp
index dd1923eb..c074238d 100644
--- a/test_conformance/basic/test_imagereadwrite.cpp
+++ b/test_conformance/basic/test_imagereadwrite.cpp
@@ -215,17 +215,20 @@ test_imagereadwrite(cl_device_id device, cl_context context, cl_command_queue qu
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT8;
-    streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT16;
-    streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_FLOAT;
-    streams[2] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, &err);
+    streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, &err);
     test_error(err, "create_image_2d failed");
 
     for (i=0; i<3; i++)
diff --git a/test_conformance/basic/test_int2float.cpp b/test_conformance/basic/test_int2float.cpp
index d298dc7f..483698a2 100644
--- a/test_conformance/basic/test_int2float.cpp
+++ b/test_conformance/basic/test_int2float.cpp
@@ -68,13 +68,15 @@ test_int2float(cl_device_id device, cl_context context, cl_command_queue queue,
 
     input_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/basic/test_local_linear_id.cpp b/test_conformance/basic/test_local_linear_id.cpp
index da6af0d7..279bd713 100644
--- a/test_conformance/basic/test_local_linear_id.cpp
+++ b/test_conformance/basic/test_local_linear_id.cpp
@@ -66,20 +66,21 @@ verify_local_linear_id(int *result, int n)
 int
 test_local_linear_id(cl_device_id device, cl_context context, cl_command_queue queue, int num_elements)
 {
-      cl_mem streams;
-      cl_program program[2];
-      cl_kernel kernel[2];
+    cl_mem streams;
+    cl_program program[2];
+    cl_kernel kernel[2];
 
     int *output_ptr;
-      size_t threads[2];
-      int err;
-      num_elements = (int)sqrt((float)num_elements);
-      int length = num_elements * num_elements;
+    size_t threads[2];
+    int err;
+    num_elements = (int)sqrt((float)num_elements);
+    int length = num_elements * num_elements;
 
-      output_ptr   = (cl_int*)malloc(sizeof(int) * length);
+    output_ptr = (cl_int *)malloc(sizeof(int) * length);
 
-    streams = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length*sizeof(int), NULL, &err);
-    test_error( err, "clCreateBuffer failed.");
+    streams = clCreateBuffer(context, CL_MEM_READ_WRITE, length * sizeof(int),
+                             NULL, &err);
+    test_error(err, "clCreateBuffer failed.");
 
     err = create_single_kernel_helper(context, &program[0], &kernel[0], 1,
                                       &local_linear_id_1d_code,
diff --git a/test_conformance/basic/test_multireadimagemultifmt.cpp b/test_conformance/basic/test_multireadimagemultifmt.cpp
index 5c93d2fc..7fe58d3c 100644
--- a/test_conformance/basic/test_multireadimagemultifmt.cpp
+++ b/test_conformance/basic/test_multireadimagemultifmt.cpp
@@ -136,7 +136,8 @@ test_mri_multiple(cl_device_id device, cl_context context, cl_command_queue queu
 
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT8;
-    streams[0] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, NULL);
+    streams[0] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, NULL);
     if (!streams[0])
     {
         log_error("create_image_2d failed\n");
@@ -144,7 +145,8 @@ test_mri_multiple(cl_device_id device, cl_context context, cl_command_queue queu
     }
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_UNORM_INT16;
-    streams[1] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, NULL);
+    streams[1] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, NULL);
     if (!streams[1])
     {
         log_error("create_image_2d failed\n");
@@ -152,14 +154,17 @@ test_mri_multiple(cl_device_id device, cl_context context, cl_command_queue queu
     }
     img_format.image_channel_order = CL_RGBA;
     img_format.image_channel_data_type = CL_FLOAT;
-    streams[2] = create_image_2d(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  &img_format, img_width, img_height, 0, NULL, NULL);
+    streams[2] = create_image_2d(context, CL_MEM_READ_WRITE, &img_format,
+                                 img_width, img_height, 0, NULL, NULL);
     if (!streams[2])
     {
         log_error("create_image_2d failed\n");
         return -1;
     }
 
-    streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(float)*4 * img_width*img_height, NULL, NULL);
+    streams[3] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(float) * 4 * img_width * img_height, NULL, NULL);
     if (!streams[3])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/basic/test_numeric_constants.cpp b/test_conformance/basic/test_numeric_constants.cpp
index 5aeca0ed..83687ee3 100644
--- a/test_conformance/basic/test_numeric_constants.cpp
+++ b/test_conformance/basic/test_numeric_constants.cpp
@@ -242,11 +242,14 @@ int test_kernel_numeric_constants(cl_device_id deviceID, cl_context context, cl_
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(float_out), NULL, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float_out),
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(int_out), NULL, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(int_out),
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(uint_out), NULL, &error);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(uint_out),
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
 
     error = clSetKernelArg(kernel, 1, sizeof( streams[1] ), &streams[1]);
@@ -348,9 +351,11 @@ int test_kernel_numeric_constants(cl_device_id deviceID, cl_context context, cl_
             return -1;
         }
 
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(long_out), NULL, &error);
+        streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    sizeof(long_out), NULL, &error);
         test_error( error, "Creating test array failed" );
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(ulong_out), NULL, &error);
+        streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    sizeof(ulong_out), NULL, &error);
         test_error( error, "Creating test array failed" );
 
         error = clSetKernelArg(kernel, 1, sizeof( streams[1] ), &streams[1]);
@@ -389,9 +394,11 @@ int test_kernel_numeric_constants(cl_device_id deviceID, cl_context context, cl_
             return -1;
         }
 
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(double_out), NULL, &error);
+        streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    sizeof(double_out), NULL, &error);
         test_error( error, "Creating test array failed" );
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(long_out), NULL, &error);
+        streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    sizeof(long_out), NULL, &error);
         test_error( error, "Creating test array failed" );
 
         error = clSetKernelArg(kernel, 1, sizeof( streams[1] ), &streams[1]);
@@ -533,9 +540,11 @@ int test_kernel_limit_constants(cl_device_id deviceID, cl_context context, cl_co
 
 
     /* Create some I/O streams */
-    intStream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(intOut), NULL, &error );
+    intStream = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(intOut), NULL,
+                               &error);
     test_error( error, "Creating test array failed" );
-    floatStream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(floatOut), NULL, &error );
+    floatStream = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(floatOut),
+                                 NULL, &error);
     test_error( error, "Creating test array failed" );
 
     // Stage 1: basic limits on MAXFLOAT
@@ -677,7 +686,8 @@ int test_kernel_limit_constants(cl_device_id deviceID, cl_context context, cl_co
                 return -1;
             }
 
-            doubleStream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(doubleOut), NULL, &error );
+            doubleStream = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                          sizeof(doubleOut), NULL, &error);
             test_error( error, "Creating test array failed" );
 
             error = clSetKernelArg( kernel, 0, sizeof( intStream ), &intStream );
diff --git a/test_conformance/basic/test_preprocessors.cpp b/test_conformance/basic/test_preprocessors.cpp
index 73f75fb0..2038d150 100644
--- a/test_conformance/basic/test_preprocessors.cpp
+++ b/test_conformance/basic/test_preprocessors.cpp
@@ -125,11 +125,14 @@ int test_kernel_preprocessor_macros(cl_device_id deviceID, cl_context context, c
     }
 
     /* Create some I/O streams */
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(results), NULL, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(results),
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(fileString), NULL, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(fileString),
+                                NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(roundingString), NULL, &error);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(roundingString), NULL, &error);
     test_error( error, "Creating test array failed" );
 
     // Set up and run
diff --git a/test_conformance/basic/test_queue_priority.cpp b/test_conformance/basic/test_queue_priority.cpp
index 831defe7..57ce5041 100644
--- a/test_conformance/basic/test_queue_priority.cpp
+++ b/test_conformance/basic/test_queue_priority.cpp
@@ -235,18 +235,18 @@ int test_queue_priority(cl_device_id device, cl_context context, cl_command_queu
     oldMode = get_round();
   }
 
-    input_ptr[0] = (cl_float*)malloc(length);
-    input_ptr[1] = (cl_float*)malloc(length);
-    input_ptr[2] = (cl_float*)malloc(length);
-    output_ptr   = (cl_float*)malloc(length);
+  input_ptr[0] = (cl_float *)malloc(length);
+  input_ptr[1] = (cl_float *)malloc(length);
+  input_ptr[2] = (cl_float *)malloc(length);
+  output_ptr = (cl_float *)malloc(length);
 
-  streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+  streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
   test_error( err, "clCreateBuffer failed.");
-  streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+  streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
   test_error( err, "clCreateBuffer failed.");
-  streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+  streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
   test_error( err, "clCreateBuffer failed.");
-  streams[3] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), length, NULL, &err);
+  streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE, length, NULL, &err);
   test_error( err, "clCreateBuffer failed.");
 
   p = input_ptr[0];
diff --git a/test_conformance/basic/test_rw_image_access_qualifier.cpp b/test_conformance/basic/test_rw_image_access_qualifier.cpp
index c841a1dd..ffb8fe15 100644
--- a/test_conformance/basic/test_rw_image_access_qualifier.cpp
+++ b/test_conformance/basic/test_rw_image_access_qualifier.cpp
@@ -121,8 +121,7 @@ int test_rw_image_access_qualifier(cl_device_id device_id, cl_context context, c
     format.image_channel_data_type = CL_UNSIGNED_INT32;
 
     /* Create input image */
-    flags = (cl_mem_flags) (CL_MEM_READ_WRITE
-                            | CL_MEM_COPY_HOST_PTR);
+    flags = CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR;
     src_image = create_image_2d(context, flags, &format,
                                 size_x, size_y, 0,
                                 (void *)input, &err);
diff --git a/test_conformance/basic/test_wg_barrier.cpp b/test_conformance/basic/test_wg_barrier.cpp
index e89f4db5..a237d80b 100644
--- a/test_conformance/basic/test_wg_barrier.cpp
+++ b/test_conformance/basic/test_wg_barrier.cpp
@@ -110,11 +110,15 @@ test_wg_barrier(cl_device_id device, cl_context context, cl_command_queue queue,
     input_ptr = (int*)malloc(sizeof(int) * num_elements);
     output_ptr = (int*)malloc(sizeof(int));
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err);
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     test_error(err, "clCreateBuffer failed.");
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int), NULL, &err);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), NULL, &err);
     test_error(err, "clCreateBuffer failed.");
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * max_threadgroup_size, NULL, &err);
+    streams[2] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * max_threadgroup_size, NULL, &err);
     test_error(err, "clCreateBuffer failed.");
 
     d = init_genrand( gRandomSeed );
diff --git a/test_conformance/buffers/array_info.cpp b/test_conformance/buffers/array_info.cpp
index be33c007..f143cf37 100644
--- a/test_conformance/buffers/array_info.cpp
+++ b/test_conformance/buffers/array_info.cpp
@@ -33,7 +33,8 @@ int test_array_info_size( cl_device_id deviceID, cl_context context, cl_command_
     size_t          retSize;
     size_t          elementSize = sizeof( cl_int );
 
-    memobj = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  elementSize * w*h*d, NULL, &err);
+    memobj = clCreateBuffer(context, CL_MEM_READ_WRITE, elementSize * w * h * d,
+                            NULL, &err);
     test_error(err, "clCreateBuffer failed.");
 
     err = clGetMemObjectInfo(memobj, CL_MEM_SIZE, sizeof( size_t ), (void *)&retSize, NULL);
diff --git a/test_conformance/buffers/test_buffer_mem.cpp b/test_conformance/buffers/test_buffer_mem.cpp
index a471c0f7..4671f1a8 100644
--- a/test_conformance/buffers/test_buffer_mem.cpp
+++ b/test_conformance/buffers/test_buffer_mem.cpp
@@ -328,7 +328,8 @@ int test_mem_read_only_flags( cl_device_id deviceID, cl_context context, cl_comm
     for (i=0; i<num_elements; i++)
         inptr[i] = i;
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     if ( err != CL_SUCCESS ){
         print_error(err, " clCreateBuffer failed to create MEM_ALLOC_GLOBAL_POOL array\n" );
         clReleaseMemObject( buffers[0]) ;
diff --git a/test_conformance/buffers/test_buffer_read.cpp b/test_conformance/buffers/test_buffer_read.cpp
index de5bdf90..d94ac87e 100644
--- a/test_conformance/buffers/test_buffer_read.cpp
+++ b/test_conformance/buffers/test_buffer_read.cpp
@@ -1233,7 +1233,8 @@ int test_buffer_read_struct(cl_device_id deviceID, cl_context context, cl_comman
         log_error( " unable to allocate %d bytes for output_ptr\n", (int)(objSize * num_elements) );
         return -1;
     }
-    buffers[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  objSize * num_elements, NULL , &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                objSize * num_elements, NULL, &err);
     if ( err != CL_SUCCESS ){
         print_error( err, " clCreateBuffer failed\n" );
         align_free( output_ptr );
@@ -1334,7 +1335,8 @@ static int testRandomReadSize( cl_device_id deviceID, cl_context context, cl_com
             }
             return -1;
         }
-        buffers[i] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),  ptrSizes[i] * num_elements, NULL, &err);
+        buffers[i] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    ptrSizes[i] * num_elements, NULL, &err);
         if ( err != CL_SUCCESS ){
             print_error(err, " clCreateBuffer failed\n" );
             for ( j = 0; j < i; j++ ){
diff --git a/test_conformance/c11_atomics/common.h b/test_conformance/c11_atomics/common.h
index 80f8b872..3f0d2c5e 100644
--- a/test_conformance/c11_atomics/common.h
+++ b/test_conformance/c11_atomics/common.h
@@ -1077,11 +1077,13 @@ int CBasicTest<HostAtomicType, HostDataType>::ExecuteSingleTest(cl_device_id dev
       return -1;
     }
     memcpy(svmAtomicBuffer, &destItems[0], typeSize * numDestItems);
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), typeSize * numDestItems, svmAtomicBuffer, NULL);
+    streams[0] = clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                                typeSize * numDestItems, svmAtomicBuffer, NULL);
   }
   else
   {
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), typeSize * numDestItems, &destItems[0], NULL);
+      streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                  typeSize * numDestItems, &destItems[0], NULL);
   }
   if (!streams[0])
   {
@@ -1102,12 +1104,18 @@ int CBasicTest<HostAtomicType, HostDataType>::ExecuteSingleTest(cl_device_id dev
     }
     if(startRefValues.size())
       memcpy(svmDataBuffer, &startRefValues[0], typeSize*threadCount*NumNonAtomicVariablesPerThread());
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_USE_HOST_PTR), typeSize*threadCount*NumNonAtomicVariablesPerThread(), svmDataBuffer, NULL);
+    streams[1] = clCreateBuffer(context, CL_MEM_USE_HOST_PTR,
+                                typeSize * threadCount
+                                    * NumNonAtomicVariablesPerThread(),
+                                svmDataBuffer, NULL);
   }
   else
   {
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)((startRefValues.size() ? CL_MEM_COPY_HOST_PTR : CL_MEM_READ_WRITE)),
-      typeSize * threadCount*NumNonAtomicVariablesPerThread(), startRefValues.size() ? &startRefValues[0] : 0, NULL);
+      streams[1] = clCreateBuffer(
+          context,
+          ((startRefValues.size() ? CL_MEM_COPY_HOST_PTR : CL_MEM_READ_WRITE)),
+          typeSize * threadCount * NumNonAtomicVariablesPerThread(),
+          startRefValues.size() ? &startRefValues[0] : 0, NULL);
   }
   if (!streams[1])
   {
diff --git a/test_conformance/clcpp/address_spaces/common.hpp b/test_conformance/clcpp/address_spaces/common.hpp
index 47b78ea9..fad7ba96 100644
--- a/test_conformance/clcpp/address_spaces/common.hpp
+++ b/test_conformance/clcpp/address_spaces/common.hpp
@@ -165,9 +165,8 @@ int run_address_spaces_test(cl_device_id device, cl_context context, cl_command_
     std::vector<TYPE> output = generate_output<TYPE>(work_size[0], 9999);
 
     // output buffer
-    buffers[0] = clCreateBuffer
-        (context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     // Execute test
diff --git a/test_conformance/clcpp/address_spaces/test_pointer_types.hpp b/test_conformance/clcpp/address_spaces/test_pointer_types.hpp
index edc50b6f..af228d0d 100644
--- a/test_conformance/clcpp/address_spaces/test_pointer_types.hpp
+++ b/test_conformance/clcpp/address_spaces/test_pointer_types.hpp
@@ -357,7 +357,8 @@ struct constant_pointer_test : public address_spaces_test<T>
         RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo");
 
         // Create constant buffer
-        auto const_buff = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_ONLY), sizeof(cl_uint), NULL, &err);
+        auto const_buff = clCreateBuffer(context, CL_MEM_READ_ONLY,
+                                         sizeof(cl_uint), NULL, &err);
         RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
         // Write m_test_value to const_buff
diff --git a/test_conformance/clcpp/api/test_ctors.hpp b/test_conformance/clcpp/api/test_ctors.hpp
index 8cdfc6ea..ae0695ca 100644
--- a/test_conformance/clcpp/api/test_ctors.hpp
+++ b/test_conformance/clcpp/api/test_ctors.hpp
@@ -128,7 +128,9 @@ int test_ctors_execution(cl_device_id device,
 
     // host vector, size == count, output[0...count-1] == 1
     std::vector<cl_uint> output(count, cl_uint(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_uint) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -298,7 +300,9 @@ AUTO_TEST_CASE(test_global_scope_ctors_executed_once)
 
     // host vector, size == count, output[0...count-1] == 1
     std::vector<cl_uint> output(count, cl_uint(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     for(size_t i = 0; i < 4; i++)
@@ -435,7 +439,9 @@ AUTO_TEST_CASE(test_global_scope_ctors_ndrange)
 
     // host vector, size == count, output[0...count-1] == 1
     std::vector<cl_uint> output(count, cl_uint(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/api/test_dtors.hpp b/test_conformance/clcpp/api/test_dtors.hpp
index 2f4fd0c7..e04cbb1c 100644
--- a/test_conformance/clcpp/api/test_dtors.hpp
+++ b/test_conformance/clcpp/api/test_dtors.hpp
@@ -114,7 +114,9 @@ AUTO_TEST_CASE(test_global_scope_dtor_is_executed)
     // host vector, size == count, output[0...count-1] == 0xbeefbeef (3203383023)
     // values in output __MUST BE__ greater than 0 for the test to work correctly
     std::vector<cl_uint> output(count, cl_uint(0xbeefbeef));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(
@@ -297,7 +299,9 @@ AUTO_TEST_CASE(test_global_scope_dtors_executed_once)
     // values in output __MUST BE__ greater than 0 for the test to work correctly
     cl_uint init_value = cl_uint(0xbeefbeef);
     std::vector<cl_uint> output(count, init_value);
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(
@@ -497,7 +501,9 @@ AUTO_TEST_CASE(test_global_scope_dtor_ndrange)
     // host vector, size == count, output[0...count-1] == 0xbeefbeef (3203383023)
     // values in output __MUST BE__ greater than 0 for the test to work correctly
     std::vector<cl_uint> output(count, cl_uint(0xbeefbeef));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_uint) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/api/test_spec_consts.hpp b/test_conformance/clcpp/api/test_spec_consts.hpp
index 1d061683..c403f4d9 100644
--- a/test_conformance/clcpp/api/test_spec_consts.hpp
+++ b/test_conformance/clcpp/api/test_spec_consts.hpp
@@ -124,7 +124,9 @@ AUTO_TEST_CASE(test_spec_consts_defaults)
 
     // host vector, size == 1, output[0] == 1
     std::vector<cl_int> output(1, cl_int(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -248,7 +250,9 @@ AUTO_TEST_CASE(test_spec_consts_many_constants)
 
     // host vector, size == 1, output[0] == 1
     std::vector<cl_int> output(1, cl_int(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
@@ -443,7 +447,9 @@ AUTO_TEST_CASE(test_spec_consts_different_types)
 
     // host vector, size == 1, output[0] == 1
     std::vector<cl_int> output(1, cl_int(1));
-    output_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &error);
+    output_buffer =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_int) * output.size(), NULL, &error);
     RETURN_ON_CL_ERROR(error, "clCreateBuffer")
 
     error = clEnqueueWriteBuffer(queue, output_buffer, CL_TRUE, 0, sizeof(cl_int) * output.size(), static_cast<void *>(output.data()), 0, NULL, NULL);
diff --git a/test_conformance/clcpp/atomics/atomic_fetch.hpp b/test_conformance/clcpp/atomics/atomic_fetch.hpp
index 5618375e..39a99488 100644
--- a/test_conformance/clcpp/atomics/atomic_fetch.hpp
+++ b/test_conformance/clcpp/atomics/atomic_fetch.hpp
@@ -130,10 +130,12 @@ int test_atomic_fetch_func(cl_device_id device, cl_context context, cl_command_q
     std::vector<TYPE> input = generate_input<TYPE>(count, op.min1(), op.max1(), std::vector<TYPE>());
     std::vector<TYPE> output = generate_output<TYPE>((count - 1) / atomic_bucket_size + 1);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/math_funcs/logarithmic_funcs.hpp b/test_conformance/clcpp/math_funcs/logarithmic_funcs.hpp
index cd25d8e8..23e98302 100644
--- a/test_conformance/clcpp/math_funcs/logarithmic_funcs.hpp
+++ b/test_conformance/clcpp/math_funcs/logarithmic_funcs.hpp
@@ -49,7 +49,8 @@ int get_ilogb_nan_zero(cl_device_id device, cl_context context, cl_command_queue
 
     std::vector<cl_int> output = generate_output<cl_int>(2);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * output.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     err = clSetKernelArg(kernel, 0, sizeof(buffers[0]), &buffers[0]);
diff --git a/test_conformance/clcpp/program_scope_ctors_dtors/common.hpp b/test_conformance/clcpp/program_scope_ctors_dtors/common.hpp
index 35bf81c9..9eb17f92 100644
--- a/test_conformance/clcpp/program_scope_ctors_dtors/common.hpp
+++ b/test_conformance/clcpp/program_scope_ctors_dtors/common.hpp
@@ -230,9 +230,8 @@ int run_ps_ctor_dtor_test(cl_device_id device, cl_context context, cl_command_qu
     std::vector<cl_uint> output = generate_output<cl_uint>(work_size[0], 9999);
 
     // device output buffer
-    buffers[0] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     // Execute test
diff --git a/test_conformance/clcpp/spec_constants/common.hpp b/test_conformance/clcpp/spec_constants/common.hpp
index 3846fe83..17b31aeb 100644
--- a/test_conformance/clcpp/spec_constants/common.hpp
+++ b/test_conformance/clcpp/spec_constants/common.hpp
@@ -213,9 +213,8 @@ int run_spec_constants_test(cl_device_id device, cl_context context, cl_command_
     std::vector<TYPE> output = generate_output<TYPE>(work_size[0], 9999);
 
     // device output buffer
-    buffers[0] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(TYPE) * output.size(), NULL, &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     // Execute test
diff --git a/test_conformance/clcpp/subgroups/test_sg_all.hpp b/test_conformance/clcpp/subgroups/test_sg_all.hpp
index 01d66386..5dc060ce 100644
--- a/test_conformance/clcpp/subgroups/test_sg_all.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_all.hpp
@@ -169,10 +169,12 @@ int sub_group_all(cl_device_id device, cl_context context, cl_command_queue queu
     std::vector<cl_uint> input = generate_input_sg_all(flat_work_size + 1, wg_size);
     std::vector<cl_uint> output = generate_output_sg_all(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/subgroups/test_sg_any.hpp b/test_conformance/clcpp/subgroups/test_sg_any.hpp
index 769bef06..4c6adce9 100644
--- a/test_conformance/clcpp/subgroups/test_sg_any.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_any.hpp
@@ -169,10 +169,12 @@ int sub_group_any(cl_device_id device, cl_context context, cl_command_queue queu
     std::vector<cl_uint> input = generate_input_sg_any(flat_work_size + 1, wg_size);
     std::vector<cl_uint> output = generate_output_sg_any(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/subgroups/test_sg_broadcast.hpp b/test_conformance/clcpp/subgroups/test_sg_broadcast.hpp
index 39e420ac..22317be5 100644
--- a/test_conformance/clcpp/subgroups/test_sg_broadcast.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_broadcast.hpp
@@ -156,10 +156,12 @@ int sub_group_broadcast(cl_device_id device, cl_context context, cl_command_queu
     std::vector<cl_uint> input = generate_input_sg_broadcast(flat_work_size, wg_size);
     std::vector<cl_uint> output = generate_output_sg_broadcast(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL,&err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/subgroups/test_sg_reduce.hpp b/test_conformance/clcpp/subgroups/test_sg_reduce.hpp
index 6b20d507..91acd474 100644
--- a/test_conformance/clcpp/subgroups/test_sg_reduce.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_reduce.hpp
@@ -223,10 +223,13 @@ int sub_group_reduce(cl_device_id device, cl_context context, cl_command_queue q
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/subgroups/test_sg_scan_exclusive.hpp b/test_conformance/clcpp/subgroups/test_sg_scan_exclusive.hpp
index 7bb2b18b..72081750 100644
--- a/test_conformance/clcpp/subgroups/test_sg_scan_exclusive.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_scan_exclusive.hpp
@@ -210,10 +210,13 @@ int sub_group_scan_exclusive(cl_device_id device, cl_context context, cl_command
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/subgroups/test_sg_scan_inclusive.hpp b/test_conformance/clcpp/subgroups/test_sg_scan_inclusive.hpp
index 803daa00..0218668c 100644
--- a/test_conformance/clcpp/subgroups/test_sg_scan_inclusive.hpp
+++ b/test_conformance/clcpp/subgroups/test_sg_scan_inclusive.hpp
@@ -210,10 +210,13 @@ int sub_group_scan_inclusive(cl_device_id device, cl_context context, cl_command
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/synchronization/named_barrier/common.hpp b/test_conformance/clcpp/synchronization/named_barrier/common.hpp
index da34dceb..e6ce8b20 100644
--- a/test_conformance/clcpp/synchronization/named_barrier/common.hpp
+++ b/test_conformance/clcpp/synchronization/named_barrier/common.hpp
@@ -133,7 +133,8 @@ int run_work_group_named_barrier_barrier_test(cl_device_id device, cl_context co
     std::vector<cl_uint> output = generate_output<cl_uint>(work_size[0], 9999);
 
     // device output buffer
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     // Execute test kernels
diff --git a/test_conformance/clcpp/synchronization/named_barrier/test_named_barrier.hpp b/test_conformance/clcpp/synchronization/named_barrier/test_named_barrier.hpp
index a4f9a04a..a0f57b24 100644
--- a/test_conformance/clcpp/synchronization/named_barrier/test_named_barrier.hpp
+++ b/test_conformance/clcpp/synchronization/named_barrier/test_named_barrier.hpp
@@ -276,7 +276,9 @@ struct global_fence_named_barrier_test : public work_group_named_barrier_test_ba
         RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
 
         // create temp buffer
-        auto temp_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * work_size, NULL, &err);
+        auto temp_buffer =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_uint) * work_size, NULL, &err);
         RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
         err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);
@@ -420,10 +422,9 @@ struct global_local_fence_named_barrier_test : public work_group_named_barrier_t
         RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
 
         // create temp buffer
-        auto temp_buffer = clCreateBuffer(
-            context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-            sizeof(cl_uint) * work_size, NULL, &err
-        );
+        auto temp_buffer =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_uint) * work_size, NULL, &err);
         RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
         err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);
diff --git a/test_conformance/clcpp/synchronization/named_barrier/test_spec_example.hpp b/test_conformance/clcpp/synchronization/named_barrier/test_spec_example.hpp
index c80ab717..7afbd00f 100644
--- a/test_conformance/clcpp/synchronization/named_barrier/test_spec_example.hpp
+++ b/test_conformance/clcpp/synchronization/named_barrier/test_spec_example.hpp
@@ -270,7 +270,9 @@ struct spec_example_work_group_named_barrier_test : public work_group_named_barr
         RETURN_ON_CL_ERROR(err, "clGetCommandQueueInfo")
 
         // create temp buffer
-        auto temp_buffer = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * work_size, NULL, &err);
+        auto temp_buffer =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_uint) * work_size, NULL, &err);
         RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
         err = clSetKernelArg(kernel, 0, sizeof(output_buffer), &output_buffer);
diff --git a/test_conformance/clcpp/utils_test/binary.hpp b/test_conformance/clcpp/utils_test/binary.hpp
index 5ff35c91..893cbed0 100644
--- a/test_conformance/clcpp/utils_test/binary.hpp
+++ b/test_conformance/clcpp/utils_test/binary.hpp
@@ -243,19 +243,16 @@ int test_binary_func(cl_device_id device, cl_context context, cl_command_queue q
     std::vector<INPUT2> input2 = generate_input<INPUT2>(count, op.min2(), op.max2(), in2_spec_cases);
     std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
 
-    buffers[0] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT1) * input1.size(), NULL, &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT1) * input1.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[1] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT2) * input2.size(), NULL, &err
-    );
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT2) * input2.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[2] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err
-    );
+    buffers[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(OUTPUT) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/utils_test/ternary.hpp b/test_conformance/clcpp/utils_test/ternary.hpp
index 342681e1..2a6f6b55 100644
--- a/test_conformance/clcpp/utils_test/ternary.hpp
+++ b/test_conformance/clcpp/utils_test/ternary.hpp
@@ -284,24 +284,20 @@ int test_ternary_func(cl_device_id device, cl_context context, cl_command_queue
     std::vector<INPUT3> input3 = generate_input<INPUT3>(count, op.min3(), op.max3(), in3_spec_cases);
     std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
 
-    buffers[0] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT1) * input1.size(), NULL, &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT1) * input1.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[1] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT2) * input2.size(), NULL, &err
-    );
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT2) * input2.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[2] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT3) * input3.size(), NULL, &err
-    );
+    buffers[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT3) * input3.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[3] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err
-    );
+    buffers[3] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(OUTPUT) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/utils_test/unary.hpp b/test_conformance/clcpp/utils_test/unary.hpp
index 2dbc6471..456ad3f0 100644
--- a/test_conformance/clcpp/utils_test/unary.hpp
+++ b/test_conformance/clcpp/utils_test/unary.hpp
@@ -215,14 +215,12 @@ int test_unary_func(cl_device_id device, cl_context context, cl_command_queue qu
     std::vector<INPUT> input = generate_input<INPUT>(count, op.min1(), op.max1(), op.in_special_cases());
     std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
 
-    buffers[0] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL,  &err
-    );
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
-    buffers[1] = clCreateBuffer(
-        context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL,  &err
-    );
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(OUTPUT) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer")
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/vload_vstore/vload_funcs.hpp b/test_conformance/clcpp/vload_vstore/vload_funcs.hpp
index 5805f8b8..cb9415e0 100644
--- a/test_conformance/clcpp/vload_vstore/vload_funcs.hpp
+++ b/test_conformance/clcpp/vload_vstore/vload_funcs.hpp
@@ -140,10 +140,12 @@ int test_vload_func(cl_device_id device, cl_context context, cl_command_queue qu
     );
     std::vector<OUTPUT> output = generate_output<OUTPUT>(count);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(OUTPUT) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/vload_vstore/vstore_funcs.hpp b/test_conformance/clcpp/vload_vstore/vstore_funcs.hpp
index 290c273f..7ffc584e 100644
--- a/test_conformance/clcpp/vload_vstore/vstore_funcs.hpp
+++ b/test_conformance/clcpp/vload_vstore/vstore_funcs.hpp
@@ -138,10 +138,12 @@ int test_vstore_func(cl_device_id device, cl_context context, cl_command_queue q
     std::vector<INPUT> input = generate_input<INPUT>(count, op.min1(), op.max1(), op.in_special_cases());
     std::vector<OUTPUT> output = generate_output<OUTPUT>(count * vector_size<INPUT>::value);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(INPUT) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(INPUT) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(OUTPUT) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(OUTPUT) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_all.hpp b/test_conformance/clcpp/workgroups/test_wg_all.hpp
index 103ce2bf..35ee5217 100644
--- a/test_conformance/clcpp/workgroups/test_wg_all.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_all.hpp
@@ -164,10 +164,12 @@ int work_group_all(cl_device_id device, cl_context context, cl_command_queue que
     std::vector<cl_uint> input = generate_input_wg_all(flat_work_size + 1, wg_size);
     std::vector<cl_uint> output = generate_output_wg_all(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_any.hpp b/test_conformance/clcpp/workgroups/test_wg_any.hpp
index 724b3ceb..1ceb1ef6 100644
--- a/test_conformance/clcpp/workgroups/test_wg_any.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_any.hpp
@@ -164,10 +164,12 @@ int work_group_any(cl_device_id device, cl_context context, cl_command_queue que
     std::vector<cl_uint> input = generate_input_wg_any(flat_work_size + 1, wg_size);
     std::vector<cl_uint> output = generate_output_wg_any(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_broadcast.hpp b/test_conformance/clcpp/workgroups/test_wg_broadcast.hpp
index 4dc5559e..999aef19 100644
--- a/test_conformance/clcpp/workgroups/test_wg_broadcast.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_broadcast.hpp
@@ -368,10 +368,12 @@ int work_group_broadcast(cl_device_id device, cl_context context, cl_command_que
     std::vector<cl_uint> input = generate_input_wg_broadcast(flat_work_size, flat_wg_size);
     std::vector<cl_uint> output = generate_output_wg_broadcast(flat_work_size, flat_wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_uint) * output.size(), NULL, &err);
+    buffers[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_reduce.hpp b/test_conformance/clcpp/workgroups/test_wg_reduce.hpp
index 616cbdb0..160b2e86 100644
--- a/test_conformance/clcpp/workgroups/test_wg_reduce.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_reduce.hpp
@@ -209,10 +209,13 @@ int work_group_reduce(cl_device_id device, cl_context context, cl_command_queue
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_scan_exclusive.hpp b/test_conformance/clcpp/workgroups/test_wg_scan_exclusive.hpp
index 35ec4b13..ef0e8ffc 100644
--- a/test_conformance/clcpp/workgroups/test_wg_scan_exclusive.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_scan_exclusive.hpp
@@ -202,10 +202,13 @@ int work_group_scan_exclusive(cl_device_id device, cl_context context, cl_comman
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/clcpp/workgroups/test_wg_scan_inclusive.hpp b/test_conformance/clcpp/workgroups/test_wg_scan_inclusive.hpp
index 34096ebb..5623aed7 100644
--- a/test_conformance/clcpp/workgroups/test_wg_scan_inclusive.hpp
+++ b/test_conformance/clcpp/workgroups/test_wg_scan_inclusive.hpp
@@ -202,10 +202,13 @@ int work_group_scan_inclusive(cl_device_id device, cl_context context, cl_comman
     std::vector<CL_INT_TYPE> input = generate_input<CL_INT_TYPE, op>(flat_work_size, wg_size);
     std::vector<CL_INT_TYPE> output = generate_output<CL_INT_TYPE, op>(flat_work_size, wg_size);
 
-    buffers[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
+    buffers[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(CL_INT_TYPE) * input.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
-    buffers[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
+    buffers[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(CL_INT_TYPE) * output.size(), NULL, &err);
     RETURN_ON_CL_ERROR(err, "clCreateBuffer");
 
     err = clEnqueueWriteBuffer(
diff --git a/test_conformance/commonfns/test_binary_fn.cpp b/test_conformance/commonfns/test_binary_fn.cpp
index 51d73659..b40bf1f6 100644
--- a/test_conformance/commonfns/test_binary_fn.cpp
+++ b/test_conformance/commonfns/test_binary_fn.cpp
@@ -86,15 +86,19 @@ int test_binary_fn( cl_device_id device, cl_context context, cl_command_queue qu
 
     for( i = 0; i < 3; i++ )
     {
-        streams[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, &err );
+        streams[i] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * num_elements, NULL, &err);
         test_error( err, "clCreateBuffer failed");
     }
 
     if (test_double)
         for( i = 3; i < 6; i++ )
         {
-          streams[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, &err );
-          test_error( err, "clCreateBuffer failed");
+            streams[i] =
+                clCreateBuffer(context, CL_MEM_READ_WRITE,
+                               sizeof(cl_double) * num_elements, NULL, &err);
+            test_error(err, "clCreateBuffer failed");
         }
 
     d = init_genrand( gRandomSeed );
diff --git a/test_conformance/commonfns/test_clamp.cpp b/test_conformance/commonfns/test_clamp.cpp
index 5d01900f..bbb83645 100644
--- a/test_conformance/commonfns/test_clamp.cpp
+++ b/test_conformance/commonfns/test_clamp.cpp
@@ -152,7 +152,9 @@ test_clamp(cl_device_id device, cl_context context, cl_command_queue queue, int
     // why does this go from 0 to 3?
     for( i = 0; i < 4; i++ )
     {
-        streams[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+        streams[i] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * num_elements, NULL, NULL);
         if (!streams[0])
         {
             log_error("clCreateBuffer failed\n");
@@ -162,8 +164,10 @@ test_clamp(cl_device_id device, cl_context context, cl_command_queue queue, int
     if (test_double)
     for( i = 4; i < 8; i++ )
         {
-        streams[ i ] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
-        if (!streams[0])
+            streams[i] =
+                clCreateBuffer(context, CL_MEM_READ_WRITE,
+                               sizeof(cl_double) * num_elements, NULL, NULL);
+            if (!streams[0])
             {
             log_error("clCreateBuffer failed\n");
             return -1;
diff --git a/test_conformance/commonfns/test_degrees.cpp b/test_conformance/commonfns/test_degrees.cpp
index d6593db3..7360c034 100644
--- a/test_conformance/commonfns/test_degrees.cpp
+++ b/test_conformance/commonfns/test_degrees.cpp
@@ -130,14 +130,16 @@ test_degrees(cl_device_id device, cl_context context, cl_command_queue queue, in
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -359,14 +361,16 @@ test_degrees_double(cl_device_id device, cl_context context, cl_command_queue qu
 
     input_ptr[0] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     output_ptr = (cl_double*)malloc(sizeof(cl_double) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_fmax.cpp b/test_conformance/commonfns/test_fmax.cpp
index 462f9e49..2441e695 100644
--- a/test_conformance/commonfns/test_fmax.cpp
+++ b/test_conformance/commonfns/test_fmax.cpp
@@ -103,19 +103,22 @@ test_fmax(cl_device_id device, cl_context context, cl_command_queue queue, int n
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_fmaxf.cpp b/test_conformance/commonfns/test_fmaxf.cpp
index 2ed1bcc2..1aed5390 100644
--- a/test_conformance/commonfns/test_fmaxf.cpp
+++ b/test_conformance/commonfns/test_fmaxf.cpp
@@ -109,20 +109,25 @@ test_fmaxf(cl_device_id device, cl_context context, cl_command_queue queue, int
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
         {
             log_error("clCreateBuffer failed\n");
             return -1;
         }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
-    if (!streams[1])
+        streams[1] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * num_elements, NULL, NULL);
+        if (!streams[1])
         {
             log_error("clCreateBuffer failed\n");
             return -1;
         }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
-    if (!streams[2])
+        streams[2] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * num_elements, NULL, NULL);
+        if (!streams[2])
         {
             log_error("clCreateBuffer failed\n");
             return -1;
diff --git a/test_conformance/commonfns/test_fmin.cpp b/test_conformance/commonfns/test_fmin.cpp
index 7efbb8fe..19bc7b65 100644
--- a/test_conformance/commonfns/test_fmin.cpp
+++ b/test_conformance/commonfns/test_fmin.cpp
@@ -108,20 +108,23 @@ test_fmin(cl_device_id device, cl_context context, cl_command_queue queue, int n
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_fminf.cpp b/test_conformance/commonfns/test_fminf.cpp
index f04fb1ef..e0e455ab 100644
--- a/test_conformance/commonfns/test_fminf.cpp
+++ b/test_conformance/commonfns/test_fminf.cpp
@@ -104,19 +104,22 @@ test_fminf(cl_device_id device, cl_context context, cl_command_queue queue, int
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_mix.cpp b/test_conformance/commonfns/test_mix.cpp
index d773f76c..51baac40 100644
--- a/test_conformance/commonfns/test_mix.cpp
+++ b/test_conformance/commonfns/test_mix.cpp
@@ -66,26 +66,30 @@ test_mix(cl_device_id device, cl_context context, cl_command_queue queue, int nu
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[2] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[3] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[3])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_radians.cpp b/test_conformance/commonfns/test_radians.cpp
index 9ff53a67..0a580c19 100644
--- a/test_conformance/commonfns/test_radians.cpp
+++ b/test_conformance/commonfns/test_radians.cpp
@@ -131,14 +131,16 @@ test_radians(cl_device_id device, cl_context context, cl_command_queue queue, in
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -361,14 +363,16 @@ test_radians_double(cl_device_id device, cl_context context, cl_command_queue qu
 
     input_ptr[0] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     output_ptr = (cl_double*)malloc(sizeof(cl_double) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_sign.cpp b/test_conformance/commonfns/test_sign.cpp
index bf8d8c79..1b842e35 100644
--- a/test_conformance/commonfns/test_sign.cpp
+++ b/test_conformance/commonfns/test_sign.cpp
@@ -117,14 +117,16 @@ test_sign(cl_device_id device, cl_context context, cl_command_queue queue, int n
 
   input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
   output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-  streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[0])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
 
-  streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[1])
   {
     log_error("clCreateBuffer failed\n");
@@ -331,14 +333,16 @@ test_sign_double(cl_device_id device, cl_context context, cl_command_queue queue
 
   input_ptr[0] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
   output_ptr = (cl_double*)malloc(sizeof(cl_double) * num_elements);
-  streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+  streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_double) * num_elements, NULL, NULL);
   if (!streams[0])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
 
-  streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+  streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_double) * num_elements, NULL, NULL);
   if (!streams[1])
   {
     log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_smoothstep.cpp b/test_conformance/commonfns/test_smoothstep.cpp
index 19201fd5..c0cc1d40 100644
--- a/test_conformance/commonfns/test_smoothstep.cpp
+++ b/test_conformance/commonfns/test_smoothstep.cpp
@@ -116,26 +116,30 @@ test_smoothstep(cl_device_id device, cl_context context, cl_command_queue queue,
   input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
   input_ptr[2] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
   output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-  streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[0])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
-  streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[1])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
-  streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[2])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
 
-  streams[3] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[3])
   {
     log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_smoothstepf.cpp b/test_conformance/commonfns/test_smoothstepf.cpp
index 7d708de7..ac09e9ec 100644
--- a/test_conformance/commonfns/test_smoothstepf.cpp
+++ b/test_conformance/commonfns/test_smoothstepf.cpp
@@ -93,26 +93,30 @@ test_smoothstepf(cl_device_id device, cl_context context, cl_command_queue queue
   input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
   input_ptr[2] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
   output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-  streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[0])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
-  streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[1])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
-  streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[2])
   {
     log_error("clCreateBuffer failed\n");
     return -1;
   }
 
-  streams[3] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+  streams[3] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                              sizeof(cl_float) * num_elements, NULL, NULL);
   if (!streams[3])
   {
     log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_step.cpp b/test_conformance/commonfns/test_step.cpp
index 3b1a5ba3..0e3cfe07 100644
--- a/test_conformance/commonfns/test_step.cpp
+++ b/test_conformance/commonfns/test_step.cpp
@@ -109,19 +109,22 @@ test_step(cl_device_id device, cl_context context, cl_command_queue queue, int n
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
@@ -373,19 +376,22 @@ test_step_double(cl_device_id device, cl_context context, cl_command_queue queue
     input_ptr[0] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     input_ptr[1] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     output_ptr = (cl_double*)malloc(sizeof(cl_double) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/commonfns/test_stepf.cpp b/test_conformance/commonfns/test_stepf.cpp
index ba7d2e1a..efada227 100644
--- a/test_conformance/commonfns/test_stepf.cpp
+++ b/test_conformance/commonfns/test_stepf.cpp
@@ -111,19 +111,22 @@ int test_stepf(cl_device_id device, cl_context context, cl_command_queue queue,
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     input_ptr[1] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
@@ -377,19 +380,22 @@ int test_stepf_double(cl_device_id device, cl_context context, cl_command_queue
     input_ptr[0] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     input_ptr[1] = (cl_double*)malloc(sizeof(cl_double) * num_elements);
     output_ptr = (cl_double*)malloc(sizeof(cl_double) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_double) * num_elements, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * num_elements, NULL, NULL);
     if (!streams[2])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/compiler/test_build_options.cpp b/test_conformance/compiler/test_build_options.cpp
index 71f84c30..7ab4454f 100644
--- a/test_conformance/compiler/test_build_options.cpp
+++ b/test_conformance/compiler/test_build_options.cpp
@@ -73,7 +73,8 @@ cl_int get_result_from_program( cl_context context, cl_command_queue queue, cl_p
     test_error( error, "Unable to create kernel from program" );
 
     clMemWrapper outStream;
-    outStream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int), NULL, &error );
+    outStream = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int), NULL,
+                               &error);
     test_error( error, "Unable to create test buffer" );
 
     error = clSetKernelArg( kernel, 0, sizeof( outStream ), &outStream );
@@ -312,7 +313,8 @@ cl_int get_float_result_from_program( cl_context context, cl_command_queue queue
     clKernelWrapper kernel = clCreateKernel( program, "sample_test", &error );
     test_error( error, "Unable to create kernel from program" );
 
-    clMemWrapper outStream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_float), NULL, &error );
+    clMemWrapper outStream = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                            sizeof(cl_float), NULL, &error);
     test_error( error, "Unable to create test buffer" );
 
     error = clSetKernelArg( kernel, 0, sizeof( cl_float ), &inA );
diff --git a/test_conformance/device_partition/test_device_partition.cpp b/test_conformance/device_partition/test_device_partition.cpp
index b90fca85..f9952ec8 100644
--- a/test_conformance/device_partition/test_device_partition.cpp
+++ b/test_conformance/device_partition/test_device_partition.cpp
@@ -265,7 +265,8 @@ int test_device_set(size_t deviceCount, size_t queueCount, cl_device_id *devices
     for( i = 0; i < TEST_SIZE; i++ )
         data[i] = genrand_int32(seed);
 
-    stream = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_int) * TEST_SIZE, data, &error);
+    stream = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                            sizeof(cl_int) * TEST_SIZE, data, &error);
     test_error( error, "Unable to create test array" );
 
     // Update the expected results
diff --git a/test_conformance/events/action_classes.cpp b/test_conformance/events/action_classes.cpp
index 122c21ff..d70d76bd 100644
--- a/test_conformance/events/action_classes.cpp
+++ b/test_conformance/events/action_classes.cpp
@@ -145,9 +145,11 @@ cl_int NDRangeKernelAction::Setup( cl_device_id device, cl_context context, cl_c
     error = get_max_common_work_group_size( context, mKernel, threads[0], &mLocalThreads[0] );
     test_error( error, "Unable to get work group size to use" );
 
-    mStreams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1000, NULL, &error );
+    mStreams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                 sizeof(cl_float) * 1000, NULL, &error);
     test_error( error, "Creating test array failed" );
-    mStreams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * 1000, NULL, &error );
+    mStreams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                 sizeof(cl_int) * 1000, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     /* Set the arguments */
diff --git a/test_conformance/events/test_events.cpp b/test_conformance/events/test_events.cpp
index c2524b16..26693f99 100644
--- a/test_conformance/events/test_events.cpp
+++ b/test_conformance/events/test_events.cpp
@@ -47,9 +47,11 @@ int create_and_execute_kernel( cl_context inContext, cl_command_queue inQueue, c
     error = get_max_common_work_group_size( inContext, *outKernel, threads[0], &localThreads[0] );
     test_error( error, "Unable to get work group size to use" );
 
-    streams[0] = clCreateBuffer(inContext, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1000, NULL, &error);
+    streams[0] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 1000, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer(inContext, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * 1000, NULL, &error);
+    streams[1] = clCreateBuffer(inContext, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * 1000, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     /* Set the arguments */
@@ -178,7 +180,8 @@ int test_event_get_write_array_status( cl_device_id deviceID, cl_context context
     cl_int status;
 
 
-    stream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                            sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     error = clEnqueueWriteBuffer(queue, stream, CL_FALSE, 0, sizeof(cl_float)*1024*32, (void *)testArray, 0, NULL, &event);
@@ -212,7 +215,8 @@ int test_event_get_read_array_status( cl_device_id deviceID, cl_context context,
     cl_int status;
 
 
-    stream = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    stream = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                            sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     error = clEnqueueReadBuffer(queue, stream, CL_FALSE, 0, sizeof(cl_float)*1024*32, (void *)testArray, 0, NULL, &event);
@@ -282,9 +286,11 @@ int test_event_wait_for_array( cl_device_id deviceID, cl_context context, cl_com
     cl_int status;
 
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0, sizeof(cl_float)*1024*32, (void *)readArray, 0, NULL, &events[0]);
@@ -421,9 +427,11 @@ int test_event_finish_array( cl_device_id deviceID, cl_context context, cl_comma
     cl_int status;
 
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * 1024 * 32, NULL, &error );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * 1024 * 32, NULL, &error);
     test_error( error, "Creating test array failed" );
 
     error = clEnqueueReadBuffer(queue, streams[0], CL_FALSE, 0, sizeof(cl_float)*1024*32, (void *)readArray, 0, NULL, &events[0]);
@@ -509,8 +517,12 @@ int test_event_release_before_done( cl_device_id deviceID, cl_context context, c
     // Create a set of streams to use as arguments
     for( i = 0; i < NUM_EVENT_RUNS; i++ )
     {
-        streams[i][0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * threads[0], NULL, &error );
-        streams[i][1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * threads[0], NULL, &error );
+        streams[i][0] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * threads[0], NULL, &error);
+        streams[i][1] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_int) * threads[0], NULL, &error);
         if( ( streams[i][0] == NULL ) || ( streams[i][1] == NULL ) )
         {
             log_error( "ERROR: Unable to allocate testing streams" );
diff --git a/test_conformance/geometrics/test_geometrics.cpp b/test_conformance/geometrics/test_geometrics.cpp
index 2fcf31ce..e305026c 100644
--- a/test_conformance/geometrics/test_geometrics.cpp
+++ b/test_conformance/geometrics/test_geometrics.cpp
@@ -188,19 +188,25 @@ int test_geom_cross(cl_device_id deviceID, cl_context context, cl_command_queue
         }
         fillWithTrickyNumbers( inDataA, inDataB, vecsize );
 
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * vecsize * TEST_SIZE, inDataA, NULL);
+        streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                    sizeof(cl_float) * vecsize * TEST_SIZE,
+                                    inDataA, NULL);
         if( streams[0] == NULL )
         {
             log_error("ERROR: Creating input array A failed!\n");
             return -1;
         }
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * vecsize * TEST_SIZE, inDataB, NULL);
+        streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                    sizeof(cl_float) * vecsize * TEST_SIZE,
+                                    inDataB, NULL);
         if( streams[1] == NULL )
         {
             log_error("ERROR: Creating input array B failed!\n");
             return -1;
         }
-        streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_float) * vecsize * TEST_SIZE, NULL, NULL);
+        streams[2] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE,
+                           sizeof(cl_float) * vecsize * TEST_SIZE, NULL, NULL);
         if( streams[2] == NULL )
         {
             log_error("ERROR: Creating output array failed!\n");
@@ -353,19 +359,24 @@ int test_twoToFloat_kernel(cl_command_queue queue, cl_context context, const cha
     }
 
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * vecSize * TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * vecSize * TEST_SIZE, inDataB, NULL);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * vecSize * TEST_SIZE, inDataB, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating input array B failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_float) * TEST_SIZE, NULL, NULL);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * TEST_SIZE, NULL, NULL);
     if( streams[2] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
@@ -660,14 +671,15 @@ int test_oneToFloat_kernel(cl_command_queue queue, cl_context context, const cha
         }
     }
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                sizeof(cl_float) * vecSize * TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE),
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
                                 sizeof(cl_float) * TEST_SIZE, NULL, NULL);
     if( streams[1] == NULL )
     {
@@ -872,13 +884,17 @@ int test_oneToOne_kernel(cl_command_queue queue, cl_context context, const char
             inDataA[i] = any_float(d);
     }
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_float) * vecSize* TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_float) * vecSize  * TEST_SIZE, NULL, NULL);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_float) * vecSize * TEST_SIZE, NULL, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
diff --git a/test_conformance/geometrics/test_geometrics_double.cpp b/test_conformance/geometrics/test_geometrics_double.cpp
index 7dec7514..222017e6 100644
--- a/test_conformance/geometrics/test_geometrics_double.cpp
+++ b/test_conformance/geometrics/test_geometrics_double.cpp
@@ -210,19 +210,22 @@ int test_geom_cross_double(cl_device_id deviceID, cl_context context, cl_command
         }
         fillWithTrickyNumbers_double( inDataA, inDataB, vecsize );
 
-        streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), bufSize, inDataA, NULL);
+        streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR, bufSize,
+                                    inDataA, NULL);
         if( streams[0] == NULL )
         {
             log_error("ERROR: Creating input array A failed!\n");
             return -1;
         }
-        streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), bufSize, inDataB, NULL);
+        streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR, bufSize,
+                                    inDataB, NULL);
         if( streams[1] == NULL )
         {
             log_error("ERROR: Creating input array B failed!\n");
             return -1;
         }
-        streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), bufSize, NULL, NULL);
+        streams[2] =
+            clCreateBuffer(context, CL_MEM_READ_WRITE, bufSize, NULL, NULL);
         if( streams[2] == NULL )
         {
             log_error("ERROR: Creating output array failed!\n");
@@ -324,19 +327,24 @@ int test_twoToFloat_kernel_double(cl_command_queue queue, cl_context context, co
     fillWithTrickyNumbers_double( inDataA, inDataB, vecSize );
 
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_double) * vecSize * TEST_SIZE, inDataB, NULL);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_double) * vecSize * TEST_SIZE, inDataB, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating input array B failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_double) * TEST_SIZE, NULL, NULL);
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * TEST_SIZE, NULL, NULL);
     if( streams[2] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
@@ -555,13 +563,16 @@ int test_oneToFloat_kernel_double(cl_command_queue queue, cl_context context, co
 
     fillWithTrickyNumbers_double( inDataA, NULL, vecSize );
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_double) * TEST_SIZE, NULL, NULL);
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_double) * TEST_SIZE, NULL, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
@@ -759,13 +770,17 @@ int test_oneToOne_kernel_double(cl_command_queue queue, cl_context context, cons
         inDataA[ i ] = any_double(d);
 
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_double) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_double) * vecSize * TEST_SIZE, NULL, NULL);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_double) * vecSize * TEST_SIZE, NULL, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
diff --git a/test_conformance/gl/test_image_methods.cpp b/test_conformance/gl/test_image_methods.cpp
index a841e2d2..afaa08fc 100644
--- a/test_conformance/gl/test_image_methods.cpp
+++ b/test_conformance/gl/test_image_methods.cpp
@@ -277,7 +277,8 @@ int test_image_format_methods( cl_device_id device, cl_context context, cl_comma
     test_error( error, "Unable to create kernel to test against" );
 
     // Create an output buffer
-    outDataBuffer = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( outKernelData ), NULL, &error );
+    outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                   sizeof(outKernelData), NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     // Set up arguments and run
diff --git a/test_conformance/images/kernel_image_methods/test_1D.cpp b/test_conformance/images/kernel_image_methods/test_1D.cpp
index 757a4a00..f0c7685e 100644
--- a/test_conformance/images/kernel_image_methods/test_1D.cpp
+++ b/test_conformance/images/kernel_image_methods/test_1D.cpp
@@ -97,7 +97,8 @@ static int test_get_1Dimage_info_single( cl_context context, cl_command_queue qu
     test_error( error, "Unable to create kernel to test against" );
 
     // Create an output buffer
-    outDataBuffer = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( outKernelData ), NULL, &error );
+    outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                   sizeof(outKernelData), NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     // Set up arguments and run
diff --git a/test_conformance/images/kernel_image_methods/test_1D_array.cpp b/test_conformance/images/kernel_image_methods/test_1D_array.cpp
index f5e778b6..5353fa65 100644
--- a/test_conformance/images/kernel_image_methods/test_1D_array.cpp
+++ b/test_conformance/images/kernel_image_methods/test_1D_array.cpp
@@ -101,7 +101,8 @@ int test_get_1Dimage_array_info_single( cl_context context, cl_command_queue que
     test_error( error, "Unable to create kernel to test against" );
 
     // Create an output buffer
-    outDataBuffer = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( outKernelData ), NULL, &error );
+    outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                   sizeof(outKernelData), NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     // Set up arguments and run
diff --git a/test_conformance/images/kernel_image_methods/test_2D.cpp b/test_conformance/images/kernel_image_methods/test_2D.cpp
index 64b9f265..05e63628 100644
--- a/test_conformance/images/kernel_image_methods/test_2D.cpp
+++ b/test_conformance/images/kernel_image_methods/test_2D.cpp
@@ -125,7 +125,8 @@ int test_get_image_info_single( cl_context context, cl_command_queue queue, imag
     test_error( error, "Unable to create kernel to test against" );
 
     // Create an output buffer
-    outDataBuffer = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( outKernelData ), NULL, &error );
+    outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                   sizeof(outKernelData), NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     // Set up arguments and run
diff --git a/test_conformance/images/kernel_image_methods/test_2D_array.cpp b/test_conformance/images/kernel_image_methods/test_2D_array.cpp
index 85b8a7a3..b9bd6bd5 100644
--- a/test_conformance/images/kernel_image_methods/test_2D_array.cpp
+++ b/test_conformance/images/kernel_image_methods/test_2D_array.cpp
@@ -105,7 +105,8 @@ int test_get_2Dimage_array_info_single( cl_context context, cl_command_queue que
     test_error( error, "Unable to create kernel to test against" );
 
     // Create an output buffer
-    outDataBuffer = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof( outKernelData ), NULL, &error );
+    outDataBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                   sizeof(outKernelData), NULL, &error);
     test_error( error, "Unable to create output buffer" );
 
     // Set up arguments and run
diff --git a/test_conformance/images/kernel_read_write/test_iterations.cpp b/test_conformance/images/kernel_read_write/test_iterations.cpp
index 0b7d4243..7281564b 100644
--- a/test_conformance/images/kernel_read_write/test_iterations.cpp
+++ b/test_conformance/images/kernel_read_write/test_iterations.cpp
@@ -1428,11 +1428,20 @@ int test_read_image_2D( cl_context context, cl_command_queue queue, cl_kernel ke
     if( gDebugTrace )
         log_info( " - Creating kernel arguments...\n" );
 
-    xOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height, xOffsetValues, &error );
+    xOffsets =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * imageInfo->width * imageInfo->height,
+                       xOffsetValues, &error);
     test_error( error, "Unable to create x offset buffer" );
-    yOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height, yOffsetValues, &error );
+    yOffsets =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_float) * imageInfo->width * imageInfo->height,
+                       yOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
-    results = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( outputType ) * 4 * imageInfo->width * imageInfo->height, NULL, &error );
+    results = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                             get_explicit_type_size(outputType) * 4
+                                 * imageInfo->width * imageInfo->height,
+                             NULL, &error);
     test_error( error, "Unable to create result buffer" );
 
     // Create sampler to use
diff --git a/test_conformance/images/kernel_read_write/test_read_1D.cpp b/test_conformance/images/kernel_read_write/test_read_1D.cpp
index e2e36a6f..f094ed63 100644
--- a/test_conformance/images/kernel_read_write/test_read_1D.cpp
+++ b/test_conformance/images/kernel_read_write/test_read_1D.cpp
@@ -394,9 +394,14 @@ int test_read_image_1D( cl_context context, cl_command_queue queue, cl_kernel ke
     if( gDebugTrace )
         log_info( " - Creating kernel arguments...\n" );
 
-    xOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width, xOffsetValues, &error );
+    xOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width,
+                              xOffsetValues, &error);
     test_error( error, "Unable to create x offset buffer" );
-    results = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( outputType ) * 4 * imageInfo->width, NULL, &error );
+    results = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                             get_explicit_type_size(outputType) * 4
+                                 * imageInfo->width,
+                             NULL, &error);
     test_error( error, "Unable to create result buffer" );
 
     // Create sampler to use
diff --git a/test_conformance/images/kernel_read_write/test_read_1D_array.cpp b/test_conformance/images/kernel_read_write/test_read_1D_array.cpp
index eede817c..1826f208 100644
--- a/test_conformance/images/kernel_read_write/test_read_1D_array.cpp
+++ b/test_conformance/images/kernel_read_write/test_read_1D_array.cpp
@@ -468,16 +468,22 @@ int test_read_image_1D_array( cl_context context, cl_command_queue queue, cl_ker
     if( gDebugTrace )
         log_info( " - Creating kernel arguments...\n" );
 
-    xOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-        sizeof( cl_float ) * imageInfo->width * imageInfo->arraySize, xOffsetValues, &error );
+    xOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->arraySize,
+                              xOffsetValues, &error);
     test_error( error, "Unable to create x offset buffer" );
 
-    yOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-        sizeof( cl_float ) * imageInfo->width * imageInfo->arraySize, yOffsetValues, &error );
+    yOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->arraySize,
+                              yOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
 
-    results = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-        get_explicit_type_size( outputType ) * 4 * imageInfo->width * imageInfo->arraySize, NULL, &error );
+    results = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                             get_explicit_type_size(outputType) * 4
+                                 * imageInfo->width * imageInfo->arraySize,
+                             NULL, &error);
     test_error( error, "Unable to create result buffer" );
 
     // Create sampler to use
diff --git a/test_conformance/images/kernel_read_write/test_read_2D_array.cpp b/test_conformance/images/kernel_read_write/test_read_2D_array.cpp
index 79420b4c..ceabceaa 100644
--- a/test_conformance/images/kernel_read_write/test_read_2D_array.cpp
+++ b/test_conformance/images/kernel_read_write/test_read_2D_array.cpp
@@ -478,13 +478,26 @@ int test_read_image_2D_array( cl_context context, cl_command_queue queue, cl_ker
         }
     }
 
-    xOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->arraySize, xOffsetValues, &error );
+    xOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->arraySize,
+                              xOffsetValues, &error);
     test_error( error, "Unable to create x offset buffer" );
-    yOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->arraySize, yOffsetValues, &error );
+    yOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->arraySize,
+                              yOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
-    zOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->arraySize, zOffsetValues, &error );
+    zOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->arraySize,
+                              zOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
-    results = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( outputType ) * 4 * imageInfo->width * imageInfo->height * imageInfo->arraySize, NULL, &error );
+    results =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       get_explicit_type_size(outputType) * 4 * imageInfo->width
+                           * imageInfo->height * imageInfo->arraySize,
+                       NULL, &error);
     test_error( error, "Unable to create result buffer" );
 
     // Create sampler to use
diff --git a/test_conformance/images/kernel_read_write/test_read_3D.cpp b/test_conformance/images/kernel_read_write/test_read_3D.cpp
index 0b9e8dee..ffb5779a 100644
--- a/test_conformance/images/kernel_read_write/test_read_3D.cpp
+++ b/test_conformance/images/kernel_read_write/test_read_3D.cpp
@@ -368,9 +368,9 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
                                             ( gEnablePitch ? imageInfo->rowPitch : 0 ),
                                             ( gEnablePitch ? imageInfo->slicePitch : 0 ), maxImageUseHostPtrBackingStore, &error );
         } else {
-            error = protImage.Create( context,
-                                    (cl_mem_flags)(image_read_write_flags),
-                                    imageInfo->format, imageInfo->width, imageInfo->height, imageInfo->depth );
+            error = protImage.Create(context, image_read_write_flags,
+                                     imageInfo->format, imageInfo->width,
+                                     imageInfo->height, imageInfo->depth);
         }
         if( error != CL_SUCCESS )
         {
@@ -487,13 +487,26 @@ int test_read_image_3D( cl_context context, cl_command_queue queue, cl_kernel ke
         }
     }
 
-    xOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->depth, xOffsetValues, &error );
+    xOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->depth,
+                              xOffsetValues, &error);
     test_error( error, "Unable to create x offset buffer" );
-    yOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->depth, yOffsetValues, &error );
+    yOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->depth,
+                              yOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
-    zOffsets = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ), sizeof( cl_float ) * imageInfo->width * imageInfo->height * imageInfo->depth, zOffsetValues, &error );
+    zOffsets = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                              sizeof(cl_float) * imageInfo->width
+                                  * imageInfo->height * imageInfo->depth,
+                              zOffsetValues, &error);
     test_error( error, "Unable to create y offset buffer" );
-    results = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  get_explicit_type_size( outputType ) * 4 * imageInfo->width * imageInfo->height * imageInfo->depth, NULL, &error );
+    results =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       get_explicit_type_size(outputType) * 4 * imageInfo->width
+                           * imageInfo->height * imageInfo->depth,
+                       NULL, &error);
     test_error( error, "Unable to create result buffer" );
 
     // Create sampler to use
diff --git a/test_conformance/images/kernel_read_write/test_write_1D.cpp b/test_conformance/images/kernel_read_write/test_write_1D.cpp
index 845ba830..bda5a442 100644
--- a/test_conformance/images/kernel_read_write/test_write_1D.cpp
+++ b/test_conformance/images/kernel_read_write/test_write_1D.cpp
@@ -271,8 +271,10 @@ int test_write_image_1D( cl_device_id device, cl_context context, cl_command_que
             clMemWrapper inputStream;
 
             char *imagePtrOffset = imageValues + nextLevelOffset;
-            inputStream = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-                                     get_explicit_type_size( inputType ) * 4 * width_lod, imagePtrOffset, &error );
+            inputStream = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                         get_explicit_type_size(inputType) * 4
+                                             * width_lod,
+                                         imagePtrOffset, &error);
             test_error( error, "Unable to create input buffer" );
 
             // Set arguments
diff --git a/test_conformance/images/kernel_read_write/test_write_1D_array.cpp b/test_conformance/images/kernel_read_write/test_write_1D_array.cpp
index 5fe928f1..1ab59604 100644
--- a/test_conformance/images/kernel_read_write/test_write_1D_array.cpp
+++ b/test_conformance/images/kernel_read_write/test_write_1D_array.cpp
@@ -285,8 +285,10 @@ int test_write_image_1D_array( cl_device_id device, cl_context context, cl_comma
             clMemWrapper inputStream;
 
             char *imagePtrOffset = imageValues + nextLevelOffset;
-            inputStream = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-                                     get_explicit_type_size( inputType ) * 4 * width_lod * imageInfo->arraySize, imagePtrOffset, &error );
+            inputStream = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                         get_explicit_type_size(inputType) * 4
+                                             * width_lod * imageInfo->arraySize,
+                                         imagePtrOffset, &error);
             test_error( error, "Unable to create input buffer" );
 
             // Set arguments
diff --git a/test_conformance/images/kernel_read_write/test_write_2D_array.cpp b/test_conformance/images/kernel_read_write/test_write_2D_array.cpp
index 01050c2c..949bc690 100644
--- a/test_conformance/images/kernel_read_write/test_write_2D_array.cpp
+++ b/test_conformance/images/kernel_read_write/test_write_2D_array.cpp
@@ -305,8 +305,11 @@ int test_write_image_2D_array( cl_device_id device, cl_context context, cl_comma
             clMemWrapper inputStream;
 
             char *imagePtrOffset = imageValues + nextLevelOffset;
-            inputStream = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-                                     get_explicit_type_size( inputType ) * 4 * width_lod * height_lod * imageInfo->arraySize, imagePtrOffset, &error );
+            inputStream =
+                clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                               get_explicit_type_size(inputType) * 4 * width_lod
+                                   * height_lod * imageInfo->arraySize,
+                               imagePtrOffset, &error);
             test_error( error, "Unable to create input buffer" );
 
             // Set arguments
diff --git a/test_conformance/images/kernel_read_write/test_write_3D.cpp b/test_conformance/images/kernel_read_write/test_write_3D.cpp
index b67a7325..1ec3f6d7 100644
--- a/test_conformance/images/kernel_read_write/test_write_3D.cpp
+++ b/test_conformance/images/kernel_read_write/test_write_3D.cpp
@@ -311,8 +311,11 @@ int test_write_image_3D( cl_device_id device, cl_context context, cl_command_que
             clMemWrapper inputStream;
 
             char *imagePtrOffset = imageValues + nextLevelOffset;
-            inputStream = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-                                     get_explicit_type_size( inputType ) * 4 * width_lod * height_lod * depth_lod, imagePtrOffset, &error );
+            inputStream =
+                clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                               get_explicit_type_size(inputType) * 4 * width_lod
+                                   * height_lod * depth_lod,
+                               imagePtrOffset, &error);
             test_error( error, "Unable to create input buffer" );
 
             // Set arguments
diff --git a/test_conformance/images/kernel_read_write/test_write_image.cpp b/test_conformance/images/kernel_read_write/test_write_image.cpp
index 37274f3a..5830370f 100644
--- a/test_conformance/images/kernel_read_write/test_write_image.cpp
+++ b/test_conformance/images/kernel_read_write/test_write_image.cpp
@@ -333,8 +333,11 @@ int test_write_image( cl_device_id device, cl_context context, cl_command_queue
 
             char *imagePtrOffset = imageValues + nextLevelOffset;
 
-            inputStream = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_COPY_HOST_PTR ),
-                                     get_explicit_type_size( inputType ) * channel_scale * width_lod * height_lod, imagePtrOffset, &error );
+            inputStream =
+                clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                               get_explicit_type_size(inputType) * channel_scale
+                                   * width_lod * height_lod,
+                               imagePtrOffset, &error);
             test_error( error, "Unable to create input buffer" );
 
             // Set arguments
diff --git a/test_conformance/integer_ops/test_int_basic_ops.cpp b/test_conformance/integer_ops/test_int_basic_ops.cpp
index 2d628d46..519e5bee 100644
--- a/test_conformance/integer_ops/test_int_basic_ops.cpp
+++ b/test_conformance/integer_ops/test_int_basic_ops.cpp
@@ -244,18 +244,21 @@ cl_int perThreadDataInit(perThreadData * pThis, ExplicitType type,
     (cl_int*)malloc(pThis->m_type_size * num_elements * vectorSize);
     pThis->m_output_ptr =
     (cl_int*)malloc(pThis->m_type_size * num_elements * vectorSize);
-    pThis->m_streams[0] =
-    clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), pThis->m_type_size * num_elements * inputAVecSize, NULL, &err);
+    pThis->m_streams[0] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        pThis->m_type_size * num_elements * inputAVecSize, NULL, &err);
 
     test_error(err, "clCreateBuffer failed");
 
-    pThis->m_streams[1] =
-    clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), pThis->m_type_size * num_elements * inputBVecSize, NULL, &err );
+    pThis->m_streams[1] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        pThis->m_type_size * num_elements * inputBVecSize, NULL, &err);
 
     test_error(err, "clCreateBuffer failed");
 
-    pThis->m_streams[2] =
-    clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), pThis->m_type_size * num_elements * vectorSize, NULL, &err );
+    pThis->m_streams[2] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        pThis->m_type_size * num_elements * vectorSize, NULL, &err);
 
     test_error(err, "clCreateBuffer failed");
 
@@ -1445,13 +1448,21 @@ int test_question_colon_op(cl_device_id deviceID, cl_context context,
     generate_random_data( type, num_elements * inputBVecSize, s_randStates, input_ptr[ 1 ] );
     generate_random_bool_data( num_elements * inputCVecSize, s_randStates, (cl_char *)input_ptr[ 2 ], type_size );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR), type_size * num_elements * inputAVecSize, input_ptr[0], &err);
+    streams[0] = clCreateBuffer(
+        context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+        type_size * num_elements * inputAVecSize, input_ptr[0], &err);
     test_error(err, "clCreateBuffer failed");
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR), type_size * num_elements * inputBVecSize, input_ptr[1], &err );
+    streams[1] = clCreateBuffer(
+        context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+        type_size * num_elements * inputBVecSize, input_ptr[1], &err);
     test_error(err, "clCreateBuffer failed");
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR), type_size * num_elements * inputCVecSize, input_ptr[2], &err );
+    streams[2] = clCreateBuffer(
+        context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+        type_size * num_elements * inputCVecSize, input_ptr[2], &err);
     test_error(err, "clCreateBuffer failed");
-    streams[3] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_WRITE_ONLY), type_size * num_elements * vectorSize, NULL, &err );
+    streams[3] =
+        clCreateBuffer(context, CL_MEM_WRITE_ONLY,
+                       type_size * num_elements * vectorSize, NULL, &err);
     test_error(err, "clCreateBuffer failed");
 
     const char *vectorString = sizeNames[ vectorSize ];
diff --git a/test_conformance/integer_ops/test_integers.cpp b/test_conformance/integer_ops/test_integers.cpp
index 727a77cf..8d77b24b 100644
--- a/test_conformance/integer_ops/test_integers.cpp
+++ b/test_conformance/integer_ops/test_integers.cpp
@@ -96,9 +96,9 @@ int test_single_param_integer_kernel(cl_command_queue queue, cl_context context,
     /* Generate some streams */
     generate_random_data( vecType, vecSize * TEST_SIZE, d, inDataA );
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                get_explicit_type_size( vecType ) * vecSize * TEST_SIZE,
-                                inDataA, NULL);
+    streams[0] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecType) * vecSize * TEST_SIZE, inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
@@ -110,9 +110,10 @@ int test_single_param_integer_kernel(cl_command_queue queue, cl_context context,
         // Op kernels use an r/w buffer for the second param, so we need to init it with data
         generate_random_data( vecType, vecSize * TEST_SIZE, d, inDataB );
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE | ( useOpKernel ? CL_MEM_COPY_HOST_PTR : 0 )),
-                                 get_explicit_type_size( vecType ) * vecSize * TEST_SIZE,
-                                ( useOpKernel ) ? &inDataB : NULL, NULL );
+    streams[1] = clCreateBuffer(
+        context, (CL_MEM_READ_WRITE | (useOpKernel ? CL_MEM_COPY_HOST_PTR : 0)),
+        get_explicit_type_size(vecType) * vecSize * TEST_SIZE,
+        (useOpKernel) ? &inDataB : NULL, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
@@ -667,25 +668,25 @@ int test_two_param_integer_kernel(cl_command_queue queue, cl_context context, co
     generate_random_data( vecAType, vecSize * TEST_SIZE, d, inDataA );
     generate_random_data( vecBType, vecSize * TEST_SIZE, d, inDataB );
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                get_explicit_type_size( vecAType ) * vecSize * TEST_SIZE,
-                                &inDataA, NULL);
+    streams[0] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecAType) * vecSize * TEST_SIZE, &inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                get_explicit_type_size( vecBType ) * vecSize * TEST_SIZE,
-                                &inDataB, NULL);
+    streams[1] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecBType) * vecSize * TEST_SIZE, &inDataB, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating input array B failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),
-                                 get_explicit_type_size( vecAType ) * vecSize * TEST_SIZE,
-                                 NULL, NULL );
+    streams[2] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        get_explicit_type_size(vecAType) * vecSize * TEST_SIZE, NULL, NULL);
     if( streams[2] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
@@ -1324,25 +1325,33 @@ int test_three_param_integer_kernel(cl_command_queue queue, cl_context context,
     generate_random_data( vecBType, vecSize * TEST_SIZE, d, inDataB );
     generate_random_data( vecCType, vecSize * TEST_SIZE, d, inDataC );
 
-    streams[0] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecAType ) * vecSize * TEST_SIZE, &inDataA, NULL);
+    streams[0] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecAType) * vecSize * TEST_SIZE, &inDataA, NULL);
     if( streams[0] == NULL )
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecBType ) * vecSize * TEST_SIZE, &inDataB, NULL);
+    streams[1] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecBType) * vecSize * TEST_SIZE, &inDataB, NULL);
     if( streams[1] == NULL )
     {
         log_error("ERROR: Creating input array B failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecCType ) * vecSize * TEST_SIZE, &inDataC, NULL);
+    streams[2] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecCType) * vecSize * TEST_SIZE, &inDataC, NULL);
     if( streams[2] == NULL )
     {
         log_error("ERROR: Creating input array C failed!\n");
         return -1;
     }
-    streams[3] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), get_explicit_type_size( destType ) * vecSize * TEST_SIZE, NULL, NULL );
+    streams[3] = clCreateBuffer(
+        context, CL_MEM_READ_WRITE,
+        get_explicit_type_size(destType) * vecSize * TEST_SIZE, NULL, NULL);
     if( streams[3] == NULL )
     {
         log_error("ERROR: Creating output array failed!\n");
diff --git a/test_conformance/integer_ops/test_unary_ops.cpp b/test_conformance/integer_ops/test_unary_ops.cpp
index 0b4d0b81..72940eaa 100644
--- a/test_conformance/integer_ops/test_unary_ops.cpp
+++ b/test_conformance/integer_ops/test_unary_ops.cpp
@@ -90,9 +90,9 @@ int test_unary_op( cl_command_queue queue, cl_context context, OpKonstants which
 
     // Generate two streams. The first is our random data to test against, the second is our control stream
     generate_random_data( vecType, vecSize * TEST_SIZE, d, inData );
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                 get_explicit_type_size( vecType ) * vecSize * TEST_SIZE,
-                                 inData, &error );
+    streams[0] = clCreateBuffer(
+        context, CL_MEM_COPY_HOST_PTR,
+        get_explicit_type_size(vecType) * vecSize * TEST_SIZE, inData, &error);
     test_error( error, "Creating input data array failed" );
 
     cl_uint bits;
@@ -110,8 +110,8 @@ int test_unary_op( cl_command_queue queue, cl_context context, OpKonstants which
             // For addition ops, the MAX control value is 1. Otherwise, it's 3
             controlData[ i ] &= ~0x02;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
-                                sizeof( controlData ), controlData, &error );
+    streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                sizeof(controlData), controlData, &error);
     test_error( error, "Unable to create control stream" );
 
     // Assign streams and execute
diff --git a/test_conformance/integer_ops/test_upsample.cpp b/test_conformance/integer_ops/test_upsample.cpp
index 2fbbcc4b..9ae3f0c3 100644
--- a/test_conformance/integer_ops/test_upsample.cpp
+++ b/test_conformance/integer_ops/test_upsample.cpp
@@ -92,19 +92,24 @@ int test_upsample_2_param_fn(cl_command_queue queue, cl_context context, const c
     }
 
     /* Set up parameters */
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sourceATypeSize * sourceAVecSize * count, sourceA, NULL );
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sourceATypeSize * sourceAVecSize * count, sourceA, NULL);
     if (!streams[0])
     {
         log_error("ERROR: Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sourceBTypeSize * sourceBVecSize * count, sourceB, NULL );
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sourceBTypeSize * sourceBVecSize * count, sourceB, NULL);
     if (!streams[1])
     {
         log_error("ERROR: Creating input array B failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), outStride * count, NULL, NULL );
+    streams[2] = clCreateBuffer(context, CL_MEM_READ_WRITE, outStride * count,
+                                NULL, NULL);
     if (!streams[2])
     {
         log_error("ERROR: Creating output array failed!\n");
diff --git a/test_conformance/multiple_device_context/test_multiple_devices.cpp b/test_conformance/multiple_device_context/test_multiple_devices.cpp
index b6f15f64..59543ade 100644
--- a/test_conformance/multiple_device_context/test_multiple_devices.cpp
+++ b/test_conformance/multiple_device_context/test_multiple_devices.cpp
@@ -91,7 +91,7 @@ int test_device_set(size_t deviceCount, size_t queueCount, cl_device_id *devices
   for( i = 0; i < TEST_SIZE; i++ )
     data[i] = genrand_int32(seed);
 
-  stream = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR),
+  stream = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
                           sizeof(cl_uint) * TEST_SIZE, data, &error);
   test_error(error, "Unable to create test array");
 
diff --git a/test_conformance/profiling/copy.cpp b/test_conformance/profiling/copy.cpp
index 83c5db27..46d15605 100644
--- a/test_conformance/profiling/copy.cpp
+++ b/test_conformance/profiling/copy.cpp
@@ -107,12 +107,14 @@ static int copy_size( cl_device_id device, cl_context context, cl_command_queue
     int_input_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     int_output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     if( !streams[0] ){
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), sizeof(cl_int) * num_elements, NULL, &err );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     if( !streams[1] ){
         log_error("clCreateBuffer failed\n");
         return -1;
@@ -250,13 +252,15 @@ static int copy_partial_size( cl_device_id device, cl_context context, cl_comman
     inptr = (cl_int *)malloc(sizeof(cl_int) * num_elements);
     outptr = (cl_int *)malloc(sizeof(cl_int) * num_elements);
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, &err );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, &err);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -467,7 +471,7 @@ static int copy_image_size( cl_device_id device, cl_context context,
     }
 
     // allocate the input image
-    flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+    flags = CL_MEM_READ_WRITE;
     memobjs[0] = create_image_2d(context, flags, &image_format_desc, w, h, 0, NULL, &err);
     if( memobjs[0] == (cl_mem)0 ) {
         free( dst );
@@ -476,7 +480,8 @@ static int copy_image_size( cl_device_id device, cl_context context,
         return -1;
     }
 
-    memobjs[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), num_bytes, NULL, &err );
+    memobjs[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE, num_bytes, NULL, &err);
     if( memobjs[1] == (cl_mem)0 ) {
         clReleaseMemObject(memobjs[0]);
         free( dst );
@@ -784,7 +789,7 @@ int test_copy_array_to_image( cl_device_id device, cl_context context, cl_comman
     }
 
     // allocate the input image
-    flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+    flags = CL_MEM_READ_WRITE;
     memobjs[0] = create_image_2d( context, flags, &image_format_desc, w, h, 0, NULL, &err );
     if( memobjs[0] == (cl_mem)0 ){
         free( dst );
@@ -793,7 +798,9 @@ int test_copy_array_to_image( cl_device_id device, cl_context context, cl_comman
         return -1;
     }
 
-    memobjs[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE), channel_nbytes * num_channels*w*h, NULL, &err );
+    memobjs[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       channel_nbytes * num_channels * w * h, NULL, &err);
     if( memobjs[1] == (cl_mem)0 ) {
         clReleaseMemObject( memobjs[0] );
         free( dst );
diff --git a/test_conformance/profiling/execute.cpp b/test_conformance/profiling/execute.cpp
index 25ebfd12..edfc043c 100644
--- a/test_conformance/profiling/execute.cpp
+++ b/test_conformance/profiling/execute.cpp
@@ -184,8 +184,9 @@ static int kernelFilter( cl_device_id device, cl_context context, cl_command_que
     threads[1] = h;
 
     // allocate the input and output image memory objects
-    memobjs[0] = create_image_2d( context, (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR),
-                                 &image_format_desc, w, h, 0, inptr, &err );
+    memobjs[0] =
+        create_image_2d(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+                        &image_format_desc, w, h, 0, inptr, &err);
     if( memobjs[0] == (cl_mem)0 ){
         log_error( " unable to create 2D image using create_image_2d\n" );
         return -1;
@@ -199,8 +200,9 @@ static int kernelFilter( cl_device_id device, cl_context context, cl_command_que
     }
 
     // allocate an array memory object to load the filter weights
-    memobjs[2] = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR ),
-                               sizeof( cl_float ) * filter_w * filter_h, &filter_weights, &err );
+    memobjs[2] = clCreateBuffer(
+        context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+        sizeof(cl_float) * filter_w * filter_h, &filter_weights, &err);
     if( memobjs[2] == (cl_mem)0 ){
         log_error( " unable to create array using clCreateBuffer\n" );
         clReleaseMemObject( memobjs[1] );
diff --git a/test_conformance/profiling/execute_multipass.cpp b/test_conformance/profiling/execute_multipass.cpp
index 70512441..a264232e 100644
--- a/test_conformance/profiling/execute_multipass.cpp
+++ b/test_conformance/profiling/execute_multipass.cpp
@@ -122,14 +122,18 @@ static int run_kernel( cl_device_id device, cl_context context, cl_command_queue
     }
 
     // allocate the input and output image memory objects
-    memobjs[0] = create_image_3d( context, (cl_mem_flags)(CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR), &image_format_desc, w, h, d, 0, 0, inptr, &err );
+    memobjs[0] =
+        create_image_3d(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
+                        &image_format_desc, w, h, d, 0, 0, inptr, &err);
     if( memobjs[0] == (cl_mem)0 ){
         log_error( " unable to create 2D image using create_image_2d\n" );
         return -1;
     }
 
     // allocate an array memory object to load the filter weights
-    memobjs[1] = clCreateBuffer( context, (cl_mem_flags)( CL_MEM_READ_WRITE ), sizeof( cl_float ) * w*h*d*nChannels, NULL, &err );
+    memobjs[1] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_float) * w * h * d * nChannels, NULL, &err);
     if( memobjs[1] == (cl_mem)0 ){
         log_error( " unable to create array using clCreateBuffer\n" );
         clReleaseMemObject( memobjs[0] );
diff --git a/test_conformance/profiling/readArray.cpp b/test_conformance/profiling/readArray.cpp
index 2260c28c..85ab9a27 100644
--- a/test_conformance/profiling/readArray.cpp
+++ b/test_conformance/profiling/readArray.cpp
@@ -639,7 +639,8 @@ int test_stream_read( cl_device_id device, cl_context context, cl_command_queue
             log_error( " unable to allocate %d bytes for outptr\n", (int)( ptrSizes[i] * num_elements ) );
             return -1;
         }
-        streams[i] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  ptrSizes[i] * num_elements, NULL, &err );
+        streams[i] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                    ptrSizes[i] * num_elements, NULL, &err);
         if( !streams[i] ){
             log_error( " clCreateBuffer failed\n" );
             free( outptr[i] );
diff --git a/test_conformance/profiling/readImage.cpp b/test_conformance/profiling/readImage.cpp
index 191044e1..9ba6b472 100644
--- a/test_conformance/profiling/readImage.cpp
+++ b/test_conformance/profiling/readImage.cpp
@@ -167,7 +167,7 @@ int read_image( cl_device_id device, cl_context context, cl_command_queue queue,
     }
 
     // allocate the input and output image memory objects
-    flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+    flags = CL_MEM_READ_WRITE;
     memobjs[0] = create_image_2d( context, flags, &image_format_desc, w, h, 0, NULL, &err );
     if( memobjs[0] == (cl_mem)0 ){
         free( dst );
@@ -176,7 +176,8 @@ int read_image( cl_device_id device, cl_context context, cl_command_queue queue,
         return -1;
     }
 
-    memobjs[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  channel_nbytes * 4 * w * h, NULL, &err );
+    memobjs[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                channel_nbytes * 4 * w * h, NULL, &err);
     if( memobjs[1] == (cl_mem)0 ){
         free( dst );
         free( (void *)inptr );
diff --git a/test_conformance/profiling/writeArray.cpp b/test_conformance/profiling/writeArray.cpp
index c3481e60..acfe8f29 100644
--- a/test_conformance/profiling/writeArray.cpp
+++ b/test_conformance/profiling/writeArray.cpp
@@ -639,7 +639,8 @@ int test_stream_write( cl_device_id device, cl_context context, cl_command_queue
 
     for( i = 0; i < loops; i++ ){
         ii = i << 1;
-        streams[ii] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  ptrSizes[i] * num_elements, NULL, &err );
+        streams[ii] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                     ptrSizes[i] * num_elements, NULL, &err);
         if( ! streams[ii] ){
             free( outptr[i] );
             log_error( " clCreateBuffer failed\n" );
@@ -647,11 +648,15 @@ int test_stream_write( cl_device_id device, cl_context context, cl_command_queue
         }
         if( ! strcmp( type, "half" ) ){
             outptr[i] = malloc( outPtrSizes[i] * num_elements * 2 );
-            streams[ii+1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  outPtrSizes[i] * 2 * num_elements, NULL, &err );
+            streams[ii + 1] =
+                clCreateBuffer(context, CL_MEM_READ_WRITE,
+                               outPtrSizes[i] * 2 * num_elements, NULL, &err);
         }
         else{
             outptr[i] = malloc( outPtrSizes[i] * num_elements );
-            streams[ii+1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  outPtrSizes[i] * num_elements, NULL, &err );
+            streams[ii + 1] =
+                clCreateBuffer(context, CL_MEM_READ_WRITE,
+                               outPtrSizes[i] * num_elements, NULL, &err);
         }
         if( ! streams[ii+1] ){
             clReleaseMemObject(streams[ii]);
diff --git a/test_conformance/profiling/writeImage.cpp b/test_conformance/profiling/writeImage.cpp
index 2615250a..fbc8fbcd 100644
--- a/test_conformance/profiling/writeImage.cpp
+++ b/test_conformance/profiling/writeImage.cpp
@@ -452,7 +452,7 @@ int write_image( cl_device_id device, cl_context context, cl_command_queue queue
     }
 
     // allocate the input and output image memory objects
-    flags = (cl_mem_flags)(CL_MEM_READ_WRITE);
+    flags = CL_MEM_READ_WRITE;
     memobjs[0] = create_image_2d( context, flags, &image_format_desc, w, h, 0, NULL, &err );
     if( memobjs[0] == (cl_mem)0 ){
         free( dst );
@@ -461,7 +461,8 @@ int write_image( cl_device_id device, cl_context context, cl_command_queue queue
         return -1;
     }
 
-    memobjs[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  channel_nbytes * 4 * w * h, NULL, &err );
+    memobjs[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                channel_nbytes * 4 * w * h, NULL, &err);
     if( memobjs[1] == (cl_mem)0 ){
         free( dst );
         free( (void *)inptr );
diff --git a/test_conformance/relationals/test_comparisons_double.cpp b/test_conformance/relationals/test_comparisons_double.cpp
index 9dc737fd..3fe1124c 100644
--- a/test_conformance/relationals/test_comparisons_double.cpp
+++ b/test_conformance/relationals/test_comparisons_double.cpp
@@ -151,13 +151,17 @@ int test_equiv_kernel_double(cl_context context, cl_command_queue queue, const c
     generate_equiv_test_data_double( inDataA, vecSize, true, d );
     generate_equiv_test_data_double( inDataB, vecSize, false, d );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof( cl_double ) * vecSize * TEST_SIZE, &inDataA, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                sizeof(cl_double) * vecSize * TEST_SIZE,
+                                &inDataA, &error);
     if( streams[0] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof( cl_double ) * vecSize * TEST_SIZE, &inDataB, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                sizeof(cl_double) * vecSize * TEST_SIZE,
+                                &inDataB, &error);
     if( streams[1] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
diff --git a/test_conformance/relationals/test_comparisons_float.cpp b/test_conformance/relationals/test_comparisons_float.cpp
index e8178d84..989c70c7 100644
--- a/test_conformance/relationals/test_comparisons_float.cpp
+++ b/test_conformance/relationals/test_comparisons_float.cpp
@@ -158,13 +158,17 @@ int test_equiv_kernel_float(cl_context context, cl_command_queue queue, const ch
     generate_equiv_test_data_float( inDataA, vecSize, true, d );
     generate_equiv_test_data_float( inDataB, vecSize, false, d );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof( cl_float ) * vecSize * TEST_SIZE, &inDataA, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                sizeof(cl_float) * vecSize * TEST_SIZE,
+                                &inDataA, &error);
     if( streams[0] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof( cl_float ) * vecSize * TEST_SIZE, &inDataB, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                sizeof(cl_float) * vecSize * TEST_SIZE,
+                                &inDataB, &error);
     if( streams[1] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
diff --git a/test_conformance/relationals/test_relationals.cpp b/test_conformance/relationals/test_relationals.cpp
index 70952409..5a874af7 100644
--- a/test_conformance/relationals/test_relationals.cpp
+++ b/test_conformance/relationals/test_relationals.cpp
@@ -89,13 +89,19 @@ int test_any_all_kernel(cl_context context, cl_command_queue queue,
     generate_random_data( vecType, TEST_SIZE * g_vector_aligns[vecSize], d, inDataA );
     memset( clearData, 0, sizeof( clearData ) );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecType ) * g_vector_aligns[vecSize] * TEST_SIZE, &inDataA, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                get_explicit_type_size(vecType)
+                                    * g_vector_aligns[vecSize] * TEST_SIZE,
+                                &inDataA, &error);
     if( streams[0] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), sizeof(cl_int) * g_vector_aligns[vecSize] * TEST_SIZE, clearData, &error );
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       sizeof(cl_int) * g_vector_aligns[vecSize] * TEST_SIZE,
+                       clearData, &error);
     if( streams[1] == NULL )
     {
         print_error( error, "Creating output array failed!\n");
@@ -363,19 +369,28 @@ int test_select_kernel(cl_context context, cl_command_queue queue, const char *f
     generate_random_data( vecType, TEST_SIZE * g_vector_aligns[vecSize], d, inDataB );
     generate_random_data( testVecType, TEST_SIZE * g_vector_aligns[vecSize], d, inDataC );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecType ) * g_vector_aligns[vecSize] * TEST_SIZE, &inDataA, &error);
+    streams[0] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                get_explicit_type_size(vecType)
+                                    * g_vector_aligns[vecSize] * TEST_SIZE,
+                                &inDataA, &error);
     if( streams[0] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
         return -1;
     }
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( vecType ) * g_vector_aligns[vecSize] * TEST_SIZE, &inDataB, &error);
+    streams[1] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                get_explicit_type_size(vecType)
+                                    * g_vector_aligns[vecSize] * TEST_SIZE,
+                                &inDataB, &error);
     if( streams[1] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
         return -1;
     }
-    streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), get_explicit_type_size( testVecType ) * g_vector_aligns[vecSize] * TEST_SIZE, &inDataC, &error);
+    streams[2] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                get_explicit_type_size(testVecType)
+                                    * g_vector_aligns[vecSize] * TEST_SIZE,
+                                &inDataC, &error);
     if( streams[2] == NULL )
     {
         print_error( error, "Creating input array A failed!\n");
diff --git a/test_conformance/relationals/test_shuffles.cpp b/test_conformance/relationals/test_shuffles.cpp
index c784b650..5fd3b6c5 100644
--- a/test_conformance/relationals/test_shuffles.cpp
+++ b/test_conformance/relationals/test_shuffles.cpp
@@ -621,16 +621,22 @@ int test_shuffle_dual_kernel(cl_context context, cl_command_queue queue,
     if( shuffleMode == kBuiltInDualInputFnMode )
         generate_random_data( vecType, (unsigned int)( numOrders * inVecSize ), d, inSecondData );
 
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), typeSize * inVecSize * numOrders, inData, &error);
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       typeSize * inVecSize * numOrders, inData, &error);
     test_error( error, "Unable to create input stream" );
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), typeSize * outRealVecSize * numOrders, outData, &error);
+    streams[1] =
+        clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                       typeSize * outRealVecSize * numOrders, outData, &error);
     test_error( error, "Unable to create output stream" );
 
     int argIndex = 0;
     if( shuffleMode == kBuiltInDualInputFnMode )
     {
-        streams[2] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_COPY_HOST_PTR), typeSize * inVecSize * numOrders, inSecondData, &error);
+        streams[2] = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
+                                    typeSize * inVecSize * numOrders,
+                                    inSecondData, &error);
         test_error( error, "Unable to create second input stream" );
 
         error = clSetKernelArg( kernel, argIndex++, sizeof( streams[ 2 ] ), &streams[ 2 ] );
diff --git a/test_conformance/spir/kernelargs.h b/test_conformance/spir/kernelargs.h
index 2aa86d7a..7c5673e8 100644
--- a/test_conformance/spir/kernelargs.h
+++ b/test_conformance/spir/kernelargs.h
@@ -348,9 +348,9 @@ public:
         if( NULL != buffer )
         {
             int error = CL_SUCCESS;
-            m_memObj = clCreateBuffer( context,
-                                       (cl_mem_flags)( CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR ),
-                                       size, buffer, &error );
+            m_memObj = clCreateBuffer(context,
+                                      CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
+                                      size, buffer, &error);
             if( error != CL_SUCCESS )
             {
                 throw Exceptions::TestError("clCreateBuffer failed\n", error);
diff --git a/test_conformance/thread_dimensions/test_thread_dimensions.cpp b/test_conformance/thread_dimensions/test_thread_dimensions.cpp
index 84f5708f..c8d22c66 100644
--- a/test_conformance/thread_dimensions/test_thread_dimensions.cpp
+++ b/test_conformance/thread_dimensions/test_thread_dimensions.cpp
@@ -501,7 +501,8 @@ test_thread_dimensions(cl_device_id device, cl_context context, cl_command_queue
     log_info("Memory allocation size to use is %gMB, max workgroup size is %d.\n", max_memory_size/(1024.0*1024.0), (int)max_workgroup_size);
 
     while (!found_size && memory_size >= max_memory_size/8) {
-        array = clCreateBuffer(context, (cl_mem_flags)(CL_MEM_READ_WRITE), memory_size, NULL, &err);
+        array =
+            clCreateBuffer(context, CL_MEM_READ_WRITE, memory_size, NULL, &err);
         if (err == CL_MEM_OBJECT_ALLOCATION_FAILURE || err == CL_OUT_OF_HOST_MEMORY) {
             memory_size -= max_memory_size/16;
             continue;
diff --git a/test_conformance/workgroups/test_wg_all.cpp b/test_conformance/workgroups/test_wg_all.cpp
index 33ebe993..2148fba7 100644
--- a/test_conformance/workgroups/test_wg_all.cpp
+++ b/test_conformance/workgroups/test_wg_all.cpp
@@ -91,14 +91,17 @@ test_work_group_all(cl_device_id device, cl_context context, cl_command_queue qu
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * (num_elements+1));
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * (num_elements+1));
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * (num_elements+1), NULL, NULL );
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_float) * (num_elements + 1), NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_any.cpp b/test_conformance/workgroups/test_wg_any.cpp
index cd1ebffc..35ce0d52 100644
--- a/test_conformance/workgroups/test_wg_any.cpp
+++ b/test_conformance/workgroups/test_wg_any.cpp
@@ -91,14 +91,17 @@ test_work_group_any(cl_device_id device, cl_context context, cl_command_queue qu
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * (num_elements+1));
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * (num_elements+1));
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * (num_elements+1), NULL, NULL );
+    streams[0] =
+        clCreateBuffer(context, CL_MEM_READ_WRITE,
+                       sizeof(cl_float) * (num_elements + 1), NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_broadcast.cpp b/test_conformance/workgroups/test_wg_broadcast.cpp
index df4263b9..3da14fb5 100644
--- a/test_conformance/workgroups/test_wg_broadcast.cpp
+++ b/test_conformance/workgroups/test_wg_broadcast.cpp
@@ -186,14 +186,16 @@ test_work_group_broadcast_1D(cl_device_id device, cl_context context, cl_command
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -311,14 +313,16 @@ test_work_group_broadcast_2D(cl_device_id device, cl_context context, cl_command
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -435,14 +439,16 @@ test_work_group_broadcast_3D(cl_device_id device, cl_context context, cl_command
 
     input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
     output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_float) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_reduce.cpp b/test_conformance/workgroups/test_wg_reduce.cpp
index 92a5165e..5da7284a 100644
--- a/test_conformance/workgroups/test_wg_reduce.cpp
+++ b/test_conformance/workgroups/test_wg_reduce.cpp
@@ -188,14 +188,16 @@ test_work_group_reduce_add_int(cl_device_id device, cl_context context, cl_comma
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -289,14 +291,16 @@ test_work_group_reduce_add_uint(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -389,14 +393,16 @@ test_work_group_reduce_add_long(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -490,14 +496,16 @@ test_work_group_reduce_add_ulong(cl_device_id device, cl_context context, cl_com
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_reduce_max.cpp b/test_conformance/workgroups/test_wg_reduce_max.cpp
index 7f37b5ad..2464beda 100644
--- a/test_conformance/workgroups/test_wg_reduce_max.cpp
+++ b/test_conformance/workgroups/test_wg_reduce_max.cpp
@@ -197,14 +197,16 @@ test_work_group_reduce_max_int(cl_device_id device, cl_context context, cl_comma
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -307,14 +309,16 @@ test_work_group_reduce_max_uint(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -416,14 +420,16 @@ test_work_group_reduce_max_long(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -526,14 +532,16 @@ test_work_group_reduce_max_ulong(cl_device_id device, cl_context context, cl_com
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_reduce_min.cpp b/test_conformance/workgroups/test_wg_reduce_min.cpp
index 9d929c81..f415aa74 100644
--- a/test_conformance/workgroups/test_wg_reduce_min.cpp
+++ b/test_conformance/workgroups/test_wg_reduce_min.cpp
@@ -197,14 +197,16 @@ test_work_group_reduce_min_int(cl_device_id device, cl_context context, cl_comma
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -307,14 +309,16 @@ test_work_group_reduce_min_uint(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -416,14 +420,16 @@ test_work_group_reduce_min_long(cl_device_id device, cl_context context, cl_comm
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -526,14 +532,16 @@ test_work_group_reduce_min_ulong(cl_device_id device, cl_context context, cl_com
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_exclusive_add.cpp b/test_conformance/workgroups/test_wg_scan_exclusive_add.cpp
index 40c50c8c..07eedc16 100644
--- a/test_conformance/workgroups/test_wg_scan_exclusive_add.cpp
+++ b/test_conformance/workgroups/test_wg_scan_exclusive_add.cpp
@@ -196,14 +196,16 @@ test_work_group_scan_exclusive_add_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -297,14 +299,16 @@ test_work_group_scan_exclusive_add_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -397,14 +401,16 @@ test_work_group_scan_exclusive_add_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -498,14 +504,16 @@ test_work_group_scan_exclusive_add_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_exclusive_max.cpp b/test_conformance/workgroups/test_wg_scan_exclusive_max.cpp
index 7f37acd2..d20a3199 100644
--- a/test_conformance/workgroups/test_wg_scan_exclusive_max.cpp
+++ b/test_conformance/workgroups/test_wg_scan_exclusive_max.cpp
@@ -196,14 +196,16 @@ test_work_group_scan_exclusive_max_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -306,14 +308,16 @@ test_work_group_scan_exclusive_max_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -415,14 +419,16 @@ test_work_group_scan_exclusive_max_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -525,14 +531,16 @@ test_work_group_scan_exclusive_max_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_exclusive_min.cpp b/test_conformance/workgroups/test_wg_scan_exclusive_min.cpp
index 61110533..eb997960 100644
--- a/test_conformance/workgroups/test_wg_scan_exclusive_min.cpp
+++ b/test_conformance/workgroups/test_wg_scan_exclusive_min.cpp
@@ -197,14 +197,16 @@ test_work_group_scan_exclusive_min_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -307,14 +309,16 @@ test_work_group_scan_exclusive_min_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -416,14 +420,16 @@ test_work_group_scan_exclusive_min_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -526,14 +532,16 @@ test_work_group_scan_exclusive_min_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_inclusive_add.cpp b/test_conformance/workgroups/test_wg_scan_inclusive_add.cpp
index 9546794b..bff0b0f7 100644
--- a/test_conformance/workgroups/test_wg_scan_inclusive_add.cpp
+++ b/test_conformance/workgroups/test_wg_scan_inclusive_add.cpp
@@ -185,14 +185,16 @@ test_work_group_scan_inclusive_add_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -286,14 +288,16 @@ test_work_group_scan_inclusive_add_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -386,14 +390,16 @@ test_work_group_scan_inclusive_add_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -487,14 +493,16 @@ test_work_group_scan_inclusive_add_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_inclusive_max.cpp b/test_conformance/workgroups/test_wg_scan_inclusive_max.cpp
index 23d518c8..c2455e9c 100644
--- a/test_conformance/workgroups/test_wg_scan_inclusive_max.cpp
+++ b/test_conformance/workgroups/test_wg_scan_inclusive_max.cpp
@@ -187,14 +187,16 @@ test_work_group_scan_inclusive_max_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -288,14 +290,16 @@ test_work_group_scan_inclusive_max_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -388,14 +392,16 @@ test_work_group_scan_inclusive_max_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -489,14 +495,16 @@ test_work_group_scan_inclusive_max_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
diff --git a/test_conformance/workgroups/test_wg_scan_inclusive_min.cpp b/test_conformance/workgroups/test_wg_scan_inclusive_min.cpp
index f4c788f5..a73c35a6 100644
--- a/test_conformance/workgroups/test_wg_scan_inclusive_min.cpp
+++ b/test_conformance/workgroups/test_wg_scan_inclusive_min.cpp
@@ -187,14 +187,16 @@ test_work_group_scan_inclusive_min_int(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
     output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_int) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -288,14 +290,16 @@ test_work_group_scan_inclusive_min_uint(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
     output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_uint) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -388,14 +392,16 @@ test_work_group_scan_inclusive_min_long(cl_device_id device, cl_context context,
 
     input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
     output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_long) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");
@@ -489,14 +495,16 @@ test_work_group_scan_inclusive_min_ulong(cl_device_id device, cl_context context
 
     input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
     output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
-    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[0])
     {
         log_error("clCreateBuffer failed\n");
         return -1;
     }
 
-    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    streams[1] = clCreateBuffer(context, CL_MEM_READ_WRITE,
+                                sizeof(cl_ulong) * num_elements, NULL, NULL);
     if (!streams[1])
     {
         log_error("clCreateBuffer failed\n");