diff --git a/test_conformance/basic/test_arrayreadwrite.cpp b/test_conformance/basic/test_arrayreadwrite.cpp
index ac2c2d7e..fe4bb995 100644
--- a/test_conformance/basic/test_arrayreadwrite.cpp
+++ b/test_conformance/basic/test_arrayreadwrite.cpp
@@ -20,31 +20,42 @@
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <vector>
 
 #include "testBase.h"
 
-REGISTER_TEST(arrayreadwrite)
+static int test_arrayreadwrite_impl(cl_device_id device, cl_context context,
+                                    cl_command_queue queue, int num_elements,
+                                    cl_mem_flags flags)
 {
-    cl_uint                *inptr, *outptr;
-    cl_mem              streams[1];
+    clMemWrapper buffer;
     int                 num_tries = 400;
     num_elements = 1024 * 1024 * 4;
-    int                 i, j, err;
-    MTdata              d;
+    MTdataHolder d(gRandomSeed);
 
-    inptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint));
-    outptr = (cl_uint*)malloc(num_elements*sizeof(cl_uint));
+    std::vector<cl_uint> reference_vals(num_elements);
+    std::vector<cl_uint> inptr(num_elements);
+    std::vector<cl_uint> outptr(num_elements);
 
     // randomize data
-    d = init_genrand( gRandomSeed );
-    for (i=0; i<num_elements; i++)
+    for (int i = 0; i < num_elements; i++)
+    {
         inptr[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
+        reference_vals[i] = (cl_uint)(genrand_int32(d) & 0x7FFFFFFF);
+    }
 
-    streams[0] = clCreateBuffer(context, CL_MEM_READ_WRITE,
-                                sizeof(cl_uint) * num_elements, NULL, &err);
+    void* host_ptr = nullptr;
+    if ((flags & CL_MEM_USE_HOST_PTR) || (flags & CL_MEM_COPY_HOST_PTR))
+    {
+        host_ptr = inptr.data();
+    }
+
+    cl_int err = CL_SUCCESS;
+    buffer = clCreateBuffer(context, flags, sizeof(cl_uint) * num_elements,
+                            host_ptr, &err);
     test_error(err, "clCreateBuffer failed");
 
-    for (i=0; i<num_tries; i++)
+    for (int i = 0; i < num_tries; i++)
     {
         int        offset;
         int        cb;
@@ -58,15 +69,19 @@ REGISTER_TEST(arrayreadwrite)
         if (cb > (num_elements - offset))
             cb = num_elements - offset;
 
-        err = clEnqueueWriteBuffer(queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), sizeof(cl_uint)*cb,&inptr[offset], 0, NULL, NULL);
+        err = clEnqueueWriteBuffer(
+            queue, buffer, CL_TRUE, offset * sizeof(cl_uint),
+            sizeof(cl_uint) * cb, &reference_vals[offset], 0, nullptr, nullptr);
         test_error(err, "clEnqueueWriteBuffer failed");
 
-        err = clEnqueueReadBuffer( queue, streams[0], CL_TRUE, offset*sizeof(cl_uint), cb*sizeof(cl_uint), &outptr[offset], 0, NULL, NULL );
+        err = clEnqueueReadBuffer(
+            queue, buffer, CL_TRUE, offset * sizeof(cl_uint),
+            cb * sizeof(cl_uint), &outptr[offset], 0, nullptr, nullptr);
         test_error(err, "clEnqueueReadBuffer failed");
 
-        for (j=offset; j<offset+cb; j++)
+        for (int j = offset; j < offset + cb; j++)
         {
-            if (inptr[j] != outptr[j])
+            if (reference_vals[j] != outptr[j])
             {
                 log_error("ARRAY read, write test failed\n");
                 err = -1;
@@ -78,13 +93,15 @@ REGISTER_TEST(arrayreadwrite)
             break;
     }
 
-    free_mtdata(d);
-    clReleaseMemObject(streams[0]);
-    free(inptr);
-    free(outptr);
-
     if (!err)
         log_info("ARRAY read, write test passed\n");
 
     return err;
 }
+
+
+REGISTER_TEST(arrayreadwrite)
+{
+    return test_arrayreadwrite_impl(device, context, queue, num_elements,
+                                    CL_MEM_READ_WRITE);
+}
diff --git a/test_conformance/basic/test_bufferreadwriterect.cpp b/test_conformance/basic/test_bufferreadwriterect.cpp
index f334115a..883bff7c 100644
--- a/test_conformance/basic/test_bufferreadwriterect.cpp
+++ b/test_conformance/basic/test_bufferreadwriterect.cpp
@@ -342,8 +342,21 @@ void CL_CALLBACK mem_obj_destructor_callback( cl_mem, void *data )
     free( data );
 }
 
-// This is the main test function for the conformance test.
-REGISTER_TEST(bufferreadwriterect)
+using test_fn = int (*)(size_t, size_t[3], size_t[3], size_t, size_t[3],
+                        size_t[3]);
+struct TestFunctions
+{
+    test_fn copy;
+    test_fn read;
+    test_fn write;
+};
+
+static int test_bufferreadwriterect_impl(cl_device_id device,
+                                         cl_context context,
+                                         cl_command_queue queue,
+                                         int num_elements,
+                                         cl_map_flags buffer_flags,
+                                         const TestFunctions& test_functions)
 {
     gQueue = queue;
     cl_int err;
@@ -434,7 +447,8 @@ REGISTER_TEST(bufferreadwriterect)
         memcpy(backing[i], verify[i], size_bytes);
 
         // Create the CL buffer.
-        buffer[i] = clCreateBuffer (context, CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, size_bytes, backing[i], &err);
+        buffer[i] =
+            clCreateBuffer(context, buffer_flags, size_bytes, backing[i], &err);
         CL_EXIT_ERROR(err,"clCreateBuffer failed for buffer %u", i);
 
         // Make sure buffer is cleaned up appropriately if we encounter an error in the rest of the calls.
@@ -499,7 +513,8 @@ REGISTER_TEST(bufferreadwriterect)
                          doffset[0], doffset[1], doffset[2], sregion[0],
                          sregion[1], sregion[2],
                          sregion[0] * sregion[1] * sregion[2]);
-                if ((err = copy_region(src, soffset, sregion, dst, doffset, dregion)))
+                if ((err = test_functions.copy(src, soffset, sregion, dst,
+                                               doffset, dregion)))
                     return err;
                 break;
             case 1:
@@ -509,7 +524,8 @@ REGISTER_TEST(bufferreadwriterect)
                          doffset[0], doffset[1], doffset[2], sregion[0],
                          sregion[1], sregion[2],
                          sregion[0] * sregion[1] * sregion[2]);
-                if ((err = read_verify_region(src, soffset, sregion, dst, doffset, dregion)))
+                if ((err = test_functions.read(src, soffset, sregion, dst,
+                                               doffset, dregion)))
                     return err;
                 break;
             case 2:
@@ -519,7 +535,8 @@ REGISTER_TEST(bufferreadwriterect)
                          doffset[0], doffset[1], doffset[2], sregion[0],
                          sregion[1], sregion[2],
                          sregion[0] * sregion[1] * sregion[2]);
-                if ((err = write_region(src, soffset, sregion, dst, doffset, dregion)))
+                if ((err = test_functions.write(src, soffset, sregion, dst,
+                                                doffset, dregion)))
                     return err;
                 break;
         }
@@ -562,3 +579,15 @@ REGISTER_TEST(bufferreadwriterect)
 
     return err;
 }
+
+// This is the main test function for the conformance test.
+REGISTER_TEST(bufferreadwriterect)
+{
+    TestFunctions test_functions;
+    test_functions.copy = copy_region;
+    test_functions.read = read_verify_region;
+    test_functions.write = write_region;
+    return test_bufferreadwriterect_impl(
+        device, context, queue, num_elements,
+        CL_MEM_USE_HOST_PTR | CL_MEM_READ_WRITE, test_functions);
+}
diff --git a/test_conformance/buffers/test_buffer_copy.cpp b/test_conformance/buffers/test_buffer_copy.cpp
index 093987f8..81dbd5cf 100644
--- a/test_conformance/buffers/test_buffer_copy.cpp
+++ b/test_conformance/buffers/test_buffer_copy.cpp
@@ -15,6 +15,7 @@
 //
 #include "harness/compat.h"
 
+#include <memory>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -36,210 +37,246 @@ static int verify_copy_buffer(int *inptr, int *outptr, int n)
     return 0;
 }
 
+using alignedOwningPtr = std::unique_ptr<cl_int[], decltype(&align_free)>;
 
 static int test_copy( cl_command_queue queue, cl_context context, int num_elements, MTdata d )
 {
-    cl_mem  buffers[2];
-    cl_int  *int_input_ptr, *int_output_ptr;
-    cl_int  err;
-    int     i;
-    int     src_flag_id, dst_flag_id;
-    int     errors = 0;
+    clMemWrapper buffers[2];
+    cl_int err = CL_SUCCESS;
 
     size_t  min_alignment = get_min_alignment(context);
 
-    int_input_ptr = (cl_int*) align_malloc(sizeof(cl_int) * num_elements, min_alignment);
-    int_output_ptr = (cl_int*)align_malloc(sizeof(cl_int) * num_elements, min_alignment);
+    alignedOwningPtr invalid_ptr{
+        (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
+        align_free
+    };
+    if (!invalid_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
+    }
+    alignedOwningPtr out_ptr{ (cl_int *)align_malloc(
+                                  sizeof(cl_int) * num_elements, min_alignment),
+                              align_free };
+    if (!out_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
+    }
+    alignedOwningPtr reference_ptr{
+        (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
+        align_free
+    };
+    if (!reference_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
+    }
 
-    for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) {
-        for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) {
+    for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++)
+    {
+        for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++)
+        {
             log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]);
 
-            for (i=0; i<num_elements; i++){
-                int_input_ptr[i] = (int)genrand_int32( d );
-                int_output_ptr[i] = 0xdeaddead; // seed with incorrect data
+            for (int i = 0; i < num_elements; i++)
+            {
+                invalid_ptr[i] = static_cast<int>(0xdeaddead);
+                out_ptr[i] = static_cast<int>(0xdeadbeef);
+                reference_ptr[i] = (int)genrand_int32(d);
             }
 
+
             if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR))
-                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],  sizeof(cl_int) * num_elements, int_input_ptr, &err);
+                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            reference_ptr.get(), &err);
             else
-                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],  sizeof(cl_int) * num_elements, NULL, &err);
+                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            nullptr, &err);
             if ( err != CL_SUCCESS ){
-                print_error(err, " clCreateBuffer failed\n" );
-                align_free( (void *)int_input_ptr );
-                align_free( (void *)int_output_ptr );
-                return -1;
+                print_error(err, "clCreateBuffer failed\n");
+                return TEST_FAIL;
             }
 
             if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR))
-                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],  sizeof(cl_int) * num_elements, int_output_ptr, &err);
+                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            invalid_ptr.get(), &err);
             else
-                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],  sizeof(cl_int) * num_elements, NULL, &err);
+                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            nullptr, &err);
             if ( err != CL_SUCCESS ){
-                print_error(err, " clCreateBuffer failed\n" );
-                clReleaseMemObject( buffers[0] );
-                align_free( (void *)int_input_ptr );
-                align_free( (void *)int_output_ptr );
-                return -1;
+                print_error(err, "clCreateBuffer failed\n");
+                return TEST_FAIL;
             }
 
             if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)) {
-                err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)int_input_ptr, 0, NULL, NULL);
+                err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0,
+                                           sizeof(cl_int) * num_elements,
+                                           reference_ptr.get(), 0, nullptr,
+                                           nullptr);
                 if ( err != CL_SUCCESS ){
-                    print_error( err, "clEnqueueWriteBuffer failed" );
-                    clReleaseMemObject( buffers[0] );
-                    clReleaseMemObject( buffers[1] );
-                    align_free( (void *)int_output_ptr );
-                    align_free( (void *)int_input_ptr );
-                    return -1;
+                    print_error(err, "clEnqueueWriteBuffer failed\n");
+                    return TEST_FAIL;
                 }
             }
 
-            err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0, sizeof(cl_int)*num_elements, 0, NULL, NULL);
+            err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], 0, 0,
+                                      sizeof(cl_int) * num_elements, 0, nullptr,
+                                      nullptr);
             if ( err != CL_SUCCESS ){
-                print_error( err, "clCopyArray failed" );
-                clReleaseMemObject( buffers[0] );
-                clReleaseMemObject( buffers[1] );
-                align_free( (void *)int_output_ptr );
-                align_free( (void *)int_input_ptr );
-                return -1;
+                print_error(err, "clCopyArray failed\n");
+                return TEST_FAIL;
             }
 
-            err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)int_output_ptr, 0, NULL, NULL );
+            err = clEnqueueReadBuffer(queue, buffers[1], true, 0,
+                                      sizeof(int) * num_elements, out_ptr.get(),
+                                      0, nullptr, nullptr);
             if ( err != CL_SUCCESS ){
-                print_error( err, "clEnqueueReadBuffer failed" );
-                clReleaseMemObject( buffers[0] );
-                clReleaseMemObject( buffers[1] );
-                align_free( (void *)int_output_ptr );
-                align_free( (void *)int_input_ptr );
-                return -1;
+                print_error(err, "clEnqueueReadBuffer failed\n");
+                return TEST_FAIL;
             }
 
-            if ( verify_copy_buffer(int_input_ptr, int_output_ptr, num_elements) ){
+            if (verify_copy_buffer(reference_ptr.get(), out_ptr.get(),
+                                   num_elements))
+            {
                 log_error( " test failed\n" );
-                errors++;
+                return TEST_FAIL;
             }
             else{
                 log_info( " test passed\n" );
             }
-    // cleanup
-            clReleaseMemObject( buffers[0] );
-            clReleaseMemObject( buffers[1] );
         } // dst flags
-    }  // src flags
-    // cleanup
-    align_free( (void *)int_output_ptr );
-    align_free( (void *)int_input_ptr );
+    } // src flags
 
-    return errors;
+    return TEST_PASS;
 
 }   // end test_copy()
 
 
 static int testPartialCopy( cl_command_queue queue, cl_context context, int num_elements, cl_uint srcStart, cl_uint dstStart, int size, MTdata d )
 {
-    cl_mem  buffers[2];
-    int     *inptr, *outptr;
-    cl_int  err;
-    int     i;
-    int     src_flag_id, dst_flag_id;
-    int     errors = 0;
+    clMemWrapper buffers[2];
+    cl_int err = CL_SUCCESS;
 
     size_t  min_alignment = get_min_alignment(context);
 
-    inptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment);
-    if ( ! inptr ){
-        log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements );
-        return -1;
+    alignedOwningPtr invalid_ptr{
+        (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
+        align_free
+    };
+    if (!invalid_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
     }
-    outptr = (int *)align_malloc( sizeof(int) * num_elements, min_alignment);
-    if ( ! outptr ){
-        log_error( " unable to allocate %d bytes of memory\n", (int)sizeof(int) * num_elements );
-        align_free( (void *)inptr );
-        return -1;
+    alignedOwningPtr out_ptr{ (cl_int *)align_malloc(
+                                  sizeof(cl_int) * num_elements, min_alignment),
+                              align_free };
+    if (!out_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
+    }
+    alignedOwningPtr reference_ptr{
+        (cl_int *)align_malloc(sizeof(cl_int) * num_elements, min_alignment),
+        align_free
+    };
+    if (!reference_ptr)
+    {
+        log_error(" unable to allocate %zu bytes of memory\n",
+                  sizeof(cl_int) * num_elements);
+        return TEST_FAIL;
     }
 
-    for (src_flag_id=0; src_flag_id < NUM_FLAGS; src_flag_id++) {
-        for (dst_flag_id=0; dst_flag_id < NUM_FLAGS; dst_flag_id++) {
+    for (int src_flag_id = 0; src_flag_id < NUM_FLAGS; src_flag_id++)
+    {
+        for (int dst_flag_id = 0; dst_flag_id < NUM_FLAGS; dst_flag_id++)
+        {
             log_info("Testing with cl_mem_flags src: %s dst: %s\n", flag_set_names[src_flag_id], flag_set_names[dst_flag_id]);
 
-            for (i=0; i<num_elements; i++){
-                inptr[i] = (int)genrand_int32( d );
-                outptr[i] = (int)0xdeaddead;    // seed with incorrect data
+            for (int i = 0; i < num_elements; i++)
+            {
+                invalid_ptr[i] = static_cast<int>(0xdeaddead);
+                out_ptr[i] = static_cast<int>(0xdeadbeef);
+                reference_ptr[i] = (int)genrand_int32(d);
             }
 
             if ((flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR))
-                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],  sizeof(cl_int) * num_elements, inptr, &err);
+                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            reference_ptr.get(), &err);
             else
-                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],  sizeof(cl_int) * num_elements, NULL, &err);
+                buffers[0] = clCreateBuffer(context, flag_set[src_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            nullptr, &err);
             if ( err != CL_SUCCESS ){
-                print_error(err, " clCreateBuffer failed\n" )
-                align_free( (void *)outptr );
-                align_free( (void *)inptr );
-                return -1;
+                print_error(err, "clCreateBuffer failed\n");
+                return TEST_FAIL;
             }
 
             if ((flag_set[dst_flag_id] & CL_MEM_USE_HOST_PTR) || (flag_set[dst_flag_id] & CL_MEM_COPY_HOST_PTR))
-                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],  sizeof(cl_int) * num_elements, outptr, &err);
+                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            invalid_ptr.get(), &err);
             else
-                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],  sizeof(cl_int) * num_elements, NULL, &err);
+                buffers[1] = clCreateBuffer(context, flag_set[dst_flag_id],
+                                            sizeof(cl_int) * num_elements,
+                                            nullptr, &err);
             if ( err != CL_SUCCESS ){
-                print_error(err, " clCreateBuffer failed\n" );
-                clReleaseMemObject( buffers[0] );
-                align_free( (void *)outptr );
-                align_free( (void *)inptr );
-                return -1;
+                print_error(err, "clCreateBuffer failed\n");
+                return TEST_FAIL;
             }
 
             if (!(flag_set[src_flag_id] & CL_MEM_USE_HOST_PTR) && !(flag_set[src_flag_id] & CL_MEM_COPY_HOST_PTR)){
-                err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0, sizeof(cl_int)*num_elements, (void *)inptr, 0, NULL, NULL);
+                err = clEnqueueWriteBuffer(queue, buffers[0], CL_TRUE, 0,
+                                           sizeof(cl_int) * num_elements,
+                                           reference_ptr.get(), 0, nullptr,
+                                           nullptr);
                 if ( err != CL_SUCCESS ){
-                    print_error( err, "clEnqueueWriteBuffer failed" );
-                    clReleaseMemObject( buffers[1] );
-                    clReleaseMemObject( buffers[0] );
-                    align_free( (void *)outptr );
-                    align_free( (void *)inptr );
-                    return -1;
+                    print_error(err, "clEnqueueWriteBuffer failed\n");
+                    return TEST_FAIL;
                 }
             }
 
-            err = clEnqueueCopyBuffer(queue, buffers[0], buffers[1], srcStart*sizeof(cl_int), dstStart*sizeof(cl_int), sizeof(cl_int)*size, 0, NULL, NULL);
+            err = clEnqueueCopyBuffer(
+                queue, buffers[0], buffers[1], srcStart * sizeof(cl_int),
+                dstStart * sizeof(cl_int), sizeof(cl_int) * size, 0, nullptr,
+                nullptr);
             if ( err != CL_SUCCESS){
-                print_error( err, "clEnqueueCopyBuffer failed" );
-                clReleaseMemObject( buffers[1] );
-                clReleaseMemObject( buffers[0] );
-                align_free( (void *)outptr );
-                align_free( (void *)inptr );
-                return -1;
+                print_error(err, "clEnqueueCopyBuffer failed\n");
+                return TEST_FAIL;
             }
 
-            err = clEnqueueReadBuffer( queue, buffers[1], true, 0, sizeof(int)*num_elements, (void *)outptr, 0, NULL, NULL );
+            err = clEnqueueReadBuffer(queue, buffers[1], true, 0,
+                                      sizeof(int) * num_elements, out_ptr.get(),
+                                      0, nullptr, nullptr);
             if ( err != CL_SUCCESS){
-                print_error( err, "clEnqueueReadBuffer failed" );
-                clReleaseMemObject( buffers[1] );
-                clReleaseMemObject( buffers[0] );
-                align_free( (void *)outptr );
-                align_free( (void *)inptr );
-                return -1;
+                print_error(err, "clEnqueueReadBuffer failed\n");
+                return TEST_FAIL;
             }
 
-            if ( verify_copy_buffer(inptr + srcStart, outptr + dstStart, size) ){
+            if (verify_copy_buffer(reference_ptr.get() + srcStart,
+                                   out_ptr.get() + dstStart, size))
+            {
                 log_error("buffer_COPY test failed\n");
-                errors++;
+                return TEST_FAIL;
             }
             else{
                 log_info("buffer_COPY test passed\n");
             }
-    // cleanup
-            clReleaseMemObject( buffers[1] );
-            clReleaseMemObject( buffers[0] );
         } // dst mem flags
     } // src mem flags
-    // cleanup
-    align_free( (void *)outptr );
-    align_free( (void *)inptr );
 
-    return errors;
+    return TEST_PASS;
 
 }   // end testPartialCopy()
 
@@ -252,15 +289,19 @@ REGISTER_TEST(buffer_copy)
 
     // test the preset size
     log_info( "set size: %d: ", num_elements );
-    if (test_copy( queue, context, num_elements, d ))
+    if (test_copy(queue, context, num_elements, d) != TEST_PASS)
+    {
         err++;
+    }
 
     // now test random sizes
     for ( i = 0; i < 8; i++ ){
         size = (int)get_random_float(2.f,131072.f, d);
         log_info( "random size: %d: ", size );
-        if (test_copy( queue, context, size, d ))
+        if (test_copy(queue, context, size, d) != TEST_PASS)
+        {
             err++;
+        }
     }
 
     free_mtdata(d);
@@ -283,8 +324,12 @@ REGISTER_TEST(buffer_partial_copy)
         size = (int)get_random_float( 8.f, (float)(num_elements - srcStart), d );
         dstStart = (cl_uint)get_random_float( 0.f, (float)(num_elements - size), d );
         log_info( "random partial copy from %d to %d, size: %d: ", (int)srcStart, (int)dstStart, size );
-        if (testPartialCopy( queue, context, num_elements, srcStart, dstStart, size, d ))
+        if (testPartialCopy(queue, context, num_elements, srcStart, dstStart,
+                            size, d)
+            != TEST_PASS)
+        {
             err++;
+        }
     }
 
     free_mtdata(d);