Added tests for 1.1 individual command entry-points. (#1594)

* Added tests for 1.1 individual command entry-points.

* Adding fixes pointed out in review: checks for CL_DEVICE_IMAGE_SUPPORT, remove redundant buffers, synchronisation issues, fixed clang-format, other minor issues.

* Fix compilation issues for Windows and macOS, fix clang-format.

* Fix compilation issue for Windows.

* Removed redundant blocking and event operations.

* Style fixes for test skip conditions.

* Fix clang format.

* Fixed function names, file names, comments and barrier test.

* Restored Individual command entry-points tests after merge with main.

* Fix clang format.

* Superficial fixes for review.
* Fix Skip() condition for barrier test
* Fix typos
* Fix new line

Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com>

test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt

@@ -4,6 +4,9 @@ set(${MODULE_NAME}_SOURCES
     main.cpp
     basic_command_buffer.cpp
     command_buffer_queue_substitution.cpp
+    command_buffer_test_fill.cpp
+    command_buffer_test_copy.cpp
+    command_buffer_test_barrier.cpp
 )
 
 include(../../CMakeCommon.txt)

test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp

@@ -0,0 +1,123 @@
+//
+// Copyright (c) 2022 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "basic_command_buffer.h"
+#include "procs.h"
+
+#include <vector>
+
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// Command-bufer barrier tests which handles below cases:
+//
+// - barrier wait list
+
+struct BarrierWithWaitListKHR : public BasicCommandBufferTest
+{
+
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    BarrierWithWaitListKHR(cl_device_id device, cl_context context,
+                           cl_command_queue queue)
+        : BasicCommandBufferTest(device, context, queue),
+          out_of_order_queue(nullptr), out_of_order_command_buffer(this),
+          event(nullptr)
+    {}
+
+    cl_int Run() override
+    {
+        cl_int error =
+            clCommandFillBufferKHR(out_of_order_command_buffer, nullptr, in_mem,
+                                   &pattern, sizeof(cl_int), 0, data_size(), 0,
+                                   nullptr, &sync_points[0], nullptr);
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        const cl_int overwritten_pattern = 0xACDC;
+        error = clCommandFillBufferKHR(out_of_order_command_buffer, nullptr,
+                                       out_mem, &overwritten_pattern,
+                                       sizeof(cl_int), 0, data_size(), 0,
+                                       nullptr, &sync_points[1], nullptr);
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        error = clCommandBarrierWithWaitListKHR(out_of_order_command_buffer,
+                                                nullptr, 2, sync_points,
+                                                nullptr, nullptr);
+        test_error(error, "clCommandBarrierWithWaitListKHR failed");
+
+        error = clCommandNDRangeKernelKHR(
+            out_of_order_command_buffer, nullptr, nullptr, kernel, 1, nullptr,
+            &num_elements, nullptr, 0, nullptr, nullptr, nullptr);
+        test_error(error, "clCommandNDRangeKernelKHR failed");
+
+        error = clFinalizeCommandBufferKHR(out_of_order_command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(
+            0, nullptr, out_of_order_command_buffer, 0, nullptr, &event);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_int> output_data(num_elements);
+        error = clEnqueueReadBuffer(out_of_order_queue, out_mem, CL_TRUE, 0,
+                                    data_size(), output_data.data(), 1, &event,
+                                    nullptr);
+        test_error(error, "clEnqueueReadBuffer failed");
+
+        for (size_t i = 0; i < num_elements; i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        out_of_order_queue = clCreateCommandQueue(
+            context, device, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &error);
+        test_error(error, "Unable to create command queue to test with");
+
+        out_of_order_command_buffer =
+            clCreateCommandBufferKHR(1, &out_of_order_queue, nullptr, &error);
+        test_error(error, "clCreateCommandBufferKHR failed");
+
+        return CL_SUCCESS;
+    }
+
+    bool Skip() override
+    {
+        return BasicCommandBufferTest::Skip() || !out_of_order_support;
+    }
+
+    const cl_int pattern = 0x16;
+    clCommandQueueWrapper out_of_order_queue;
+    clCommandBufferWrapper out_of_order_command_buffer;
+    clEventWrapper event;
+    cl_sync_point_khr sync_points[2];
+    clEventWrapper user_event;
+};
+};
+
+
+int test_barrier_wait_list(cl_device_id device, cl_context context,
+                           cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<BarrierWithWaitListKHR>(device, context, queue,
+                                                  num_elements);
+}

test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp

@@ -0,0 +1,394 @@
+//
+// Copyright (c) 2022 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "basic_command_buffer.h"
+#include "harness/typeWrappers.h"
+#include "procs.h"
+
+#include <vector>
+
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// Command-buffer copy tests which handles below cases:
+//
+// -copy image
+// -copy buffer
+// -copy buffer to image
+// -copy image to buffer
+// -copy buffer rect
+
+struct CopyImageKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error = clCommandFillImageKHR(command_buffer, nullptr, src_image,
+                                             fill_color, origin, region, 0,
+                                             nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandFillImageKHR failed");
+
+        error = clCommandCopyImageKHR(command_buffer, nullptr, src_image,
+                                      dst_image, origin, origin, region, 0, 0,
+                                      nullptr, nullptr);
+
+        test_error(error, "clCommandCopyImageKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size);
+        error = clEnqueueReadImage(queue, dst_image, CL_TRUE, origin, region, 0,
+                                   0, output_data.data(), 0, nullptr, nullptr);
+
+        for (size_t i = 0; i < data_size; i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        src_image = create_image_2d(context, CL_MEM_READ_ONLY, &formats,
+                                    img_width, img_height, 0, NULL, &error);
+        test_error(error, "create_image_2d failed");
+
+        dst_image = create_image_2d(context, CL_MEM_WRITE_ONLY, &formats,
+                                    img_width, img_height, 0, NULL, &error);
+        test_error(error, "create_image_2d failed");
+
+        return CL_SUCCESS;
+    }
+
+    bool Skip() override
+    {
+        bool imageSupport =
+            checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
+
+        return imageSupport || BasicCommandBufferTest::Skip();
+    }
+
+    const size_t img_width = 512;
+    const size_t img_height = 512;
+    const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
+    const size_t origin[3] = { 0, 0, 0 },
+                 region[3] = { img_width, img_height, 1 };
+    const cl_uint pattern = 0x05;
+    const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern };
+    const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
+    clMemWrapper src_image;
+    clMemWrapper dst_image;
+};
+
+struct CopyBufferKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error = clCommandFillBufferKHR(
+            command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0,
+            data_size(), 0, nullptr, nullptr, nullptr);
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        error = clCommandCopyBufferKHR(command_buffer, nullptr, in_mem, out_mem,
+                                       0, 0, data_size(), 0, nullptr, nullptr,
+                                       nullptr);
+        test_error(error, "clCommandCopyBufferKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size());
+        error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
+                                    output_data.data(), 0, nullptr, nullptr);
+        test_error(error, "clEnqueueReadBuffer failed");
+
+        for (size_t i = 0; i < data_size(); i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    const cl_char pattern = 0x14;
+};
+
+struct CopyBufferToImageKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error = clCommandFillBufferKHR(
+            command_buffer, nullptr, buffer, &pattern, sizeof(cl_char), 0,
+            data_size, 0, nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        error = clCommandCopyBufferToImageKHR(command_buffer, nullptr, buffer,
+                                              image, 0, origin, region, 0, 0,
+                                              nullptr, nullptr);
+
+        test_error(error, "clCommandCopyBufferToImageKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size);
+
+        error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
+                                   output_data.data(), 0, nullptr, nullptr);
+        test_error(error, "clEnqueueReadImage failed");
+
+        for (size_t i = 0; i < data_size; i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
+                                img_height, 0, NULL, &error);
+        test_error(error, "create_image_2d failed");
+
+        buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
+                                &error);
+        test_error(error, "Unable to create buffer");
+
+        return CL_SUCCESS;
+    }
+
+    bool Skip() override
+    {
+        bool imageSupport =
+            checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
+
+        return imageSupport || BasicCommandBufferTest::Skip();
+    }
+
+    const size_t img_width = 512;
+    const size_t img_height = 512;
+    const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
+    const size_t origin[3] = { 0, 0, 0 },
+                 region[3] = { img_width, img_height, 1 };
+    const cl_char pattern = 0x11;
+    const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
+
+    clMemWrapper buffer;
+    clMemWrapper image;
+};
+
+struct CopyImageToBufferKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error =
+            clCommandFillImageKHR(command_buffer, nullptr, image, fill_color,
+                                  origin, region, 0, nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandFillImageKHR failed");
+
+        error = clCommandCopyImageToBufferKHR(command_buffer, nullptr, image,
+                                              buffer, origin, region, 0, 0,
+                                              nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandCopyImageToBufferKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size);
+
+        error = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, data_size,
+                                    output_data.data(), 0, nullptr, nullptr);
+        test_error(error, "clEnqueueReadBuffer failed");
+
+        for (size_t i = 0; i < data_size; i++)
+        {
+            CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern),
+                                     output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
+                                img_height, 0, NULL, &error);
+        test_error(error, "create_image_2d failed");
+
+        buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
+                                &error);
+        test_error(error, "Unable to create buffer");
+
+        return CL_SUCCESS;
+    }
+
+    bool Skip() override
+    {
+        bool imageSupport =
+            checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
+
+        return imageSupport || BasicCommandBufferTest::Skip();
+    }
+
+    const size_t img_width = 512;
+    const size_t img_height = 512;
+    const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
+    const size_t origin[3] = { 0, 0, 0 },
+                 region[3] = { img_width, img_height, 1 };
+    const cl_uint pattern = 0x12;
+    const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern };
+    const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
+
+    clMemWrapper image;
+    clMemWrapper buffer;
+};
+
+struct CopyBufferRectKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error = clCommandFillBufferKHR(
+            command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0,
+            data_size, 0, nullptr, nullptr, nullptr);
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        error = clCommandCopyBufferRectKHR(
+            command_buffer, nullptr, in_mem, out_mem, origin, origin, region, 0,
+            0, 0, 0, 0, nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandCopyBufferRectKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size);
+        error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size,
+                                    output_data.data(), 0, nullptr, nullptr);
+        test_error(error, "clEnqueueReadBuffer failed");
+
+        for (size_t i = 0; i < data_size; i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        in_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
+                                &error);
+        test_error(error, "clCreateBuffer failed");
+
+        out_mem = clCreateBuffer(context, CL_MEM_READ_WRITE, data_size, nullptr,
+                                 &error);
+        test_error(error, "Unable to create buffer");
+
+        return CL_SUCCESS;
+    }
+
+    const size_t img_width = 512;
+    const size_t img_height = 512;
+    const size_t data_size = img_width * img_height * sizeof(cl_char);
+    const size_t origin[3] = { 0, 0, 0 },
+                 region[3] = { img_width, img_height, 1 };
+    const cl_char pattern = 0x13;
+
+    clMemWrapper in_mem;
+    clMemWrapper out_mem;
+};
+};
+
+int test_copy_image(cl_device_id device, cl_context context,
+                    cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<CopyImageKHR>(device, context, queue, num_elements);
+}
+
+int test_copy_buffer(cl_device_id device, cl_context context,
+                     cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<CopyBufferKHR>(device, context, queue, num_elements);
+}
+
+int test_copy_buffer_to_image(cl_device_id device, cl_context context,
+                              cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<CopyBufferToImageKHR>(device, context, queue,
+                                                num_elements);
+}
+
+int test_copy_image_to_buffer(cl_device_id device, cl_context context,
+                              cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<CopyImageToBufferKHR>(device, context, queue,
+                                                num_elements);
+}
+
+int test_copy_buffer_rect(cl_device_id device, cl_context context,
+                          cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<CopyBufferRectKHR>(device, context, queue,
+                                             num_elements);
+}

test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_fill.cpp

@@ -0,0 +1,142 @@
+//
+// Copyright (c) 2022 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "basic_command_buffer.h"
+#include "harness/typeWrappers.h"
+#include "procs.h"
+
+#include <vector>
+
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// Command-buffer fill tests which handles below cases:
+//
+// -fill image
+// -fill buffer
+
+struct FillImageKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error =
+            clCommandFillImageKHR(command_buffer, nullptr, image, fill_color,
+                                  origin, region, 0, nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandFillImageKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size);
+        error = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, 0, 0,
+                                   output_data.data(), 0, nullptr, nullptr);
+
+        for (size_t i = 0; i < data_size; i++)
+        {
+            CHECK_VERIFICATION_ERROR(static_cast<cl_char>(pattern),
+                                     output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    cl_int SetUp(int elements) override
+    {
+        cl_int error = BasicCommandBufferTest::SetUp(elements);
+        test_error(error, "BasicCommandBufferTest::SetUp failed");
+
+        image = create_image_2d(context, CL_MEM_READ_WRITE, &formats, img_width,
+                                img_height, 0, NULL, &error);
+        test_error(error, "create_image_2d failed");
+
+        return CL_SUCCESS;
+    }
+
+    bool Skip() override
+    {
+        bool imageSupport =
+            checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED;
+
+        return imageSupport || BasicCommandBufferTest::Skip();
+    }
+
+    const size_t img_width = 512;
+    const size_t img_height = 512;
+    const size_t data_size = img_width * img_height * 4 * sizeof(cl_char);
+    const size_t origin[3] = { 0, 0, 0 },
+                 region[3] = { img_width, img_height, 1 };
+    const cl_uint pattern = 0x10;
+    const cl_uint fill_color[4] = { pattern, pattern, pattern, pattern };
+    const cl_image_format formats = { CL_RGBA, CL_UNSIGNED_INT8 };
+
+    clMemWrapper image;
+};
+
+struct FillBufferKHR : public BasicCommandBufferTest
+{
+    using BasicCommandBufferTest::BasicCommandBufferTest;
+
+    cl_int Run() override
+    {
+        cl_int error = clCommandFillBufferKHR(
+            command_buffer, nullptr, in_mem, &pattern, sizeof(cl_char), 0,
+            data_size(), 0, nullptr, nullptr, nullptr);
+
+        test_error(error, "clCommandFillBufferKHR failed");
+
+        error = clFinalizeCommandBufferKHR(command_buffer);
+        test_error(error, "clFinalizeCommandBufferKHR failed");
+
+        error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
+                                          nullptr, nullptr);
+        test_error(error, "clEnqueueCommandBufferKHR failed");
+
+        std::vector<cl_char> output_data(data_size());
+        error = clEnqueueReadBuffer(queue, in_mem, CL_TRUE, 0, data_size(),
+                                    output_data.data(), 0, nullptr, nullptr);
+        test_error(error, "clEnqueueReadBuffer failed");
+
+        for (size_t i = 0; i < data_size(); i++)
+        {
+            CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
+        }
+
+        return CL_SUCCESS;
+    }
+
+    const char pattern = 0x15;
+};
+
+};
+
+int test_fill_buffer(cl_device_id device, cl_context context,
+                     cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<FillBufferKHR>(device, context, queue, num_elements);
+}
+
+int test_fill_image(cl_device_id device, cl_context context,
+                    cl_command_queue queue, int num_elements)
+{
+    return MakeAndRunTest<FillImageKHR>(device, context, queue, num_elements);
+}

test_conformance/extensions/cl_khr_command_buffer/main.cpp

@@ -15,15 +15,25 @@
 #include "procs.h"
 #include "harness/testHarness.h"
 
-test_definition test_list[] = { ADD_TEST(single_ndrange),
-                                ADD_TEST(interleaved_enqueue),
-                                ADD_TEST(mixed_commands),
-                                ADD_TEST(explicit_flush),
-                                ADD_TEST(user_events),
-                                ADD_TEST(out_of_order),
-                                ADD_TEST(queue_substitution),
-                                ADD_TEST(properties_queue_substitution),
-                                ADD_TEST(simultaneous_queue_substitution) };
+test_definition test_list[] = {
+    ADD_TEST(single_ndrange),
+    ADD_TEST(interleaved_enqueue),
+    ADD_TEST(mixed_commands),
+    ADD_TEST(explicit_flush),
+    ADD_TEST(user_events),
+    ADD_TEST(out_of_order),
+    ADD_TEST(queue_substitution),
+    ADD_TEST(properties_queue_substitution),
+    ADD_TEST(simultaneous_queue_substitution),
+    ADD_TEST(fill_image),
+    ADD_TEST(fill_buffer),
+    ADD_TEST(copy_image),
+    ADD_TEST(copy_buffer),
+    ADD_TEST(copy_buffer_to_image),
+    ADD_TEST(copy_image_to_buffer),
+    ADD_TEST(copy_buffer_rect),
+    ADD_TEST(barrier_wait_list),
+};
 
 
 int main(int argc, const char *argv[])

test_conformance/extensions/cl_khr_command_buffer/procs.h

@@ -41,6 +41,22 @@ extern int test_simultaneous_queue_substitution(cl_device_id device,
                                                 cl_context context,
                                                 cl_command_queue queue,
                                                 int num_elements);
+extern int test_fill_image(cl_device_id device, cl_context context,
+                           cl_command_queue queue, int num_elements);
+extern int test_fill_buffer(cl_device_id device, cl_context context,
+                            cl_command_queue queue, int num_elements);
+extern int test_copy_image(cl_device_id device, cl_context context,
+                           cl_command_queue queue, int num_elements);
+extern int test_copy_buffer(cl_device_id device, cl_context context,
+                            cl_command_queue queue, int num_elements);
+extern int test_copy_buffer_to_image(cl_device_id device, cl_context context,
+                                     cl_command_queue queue, int num_elements);
+extern int test_copy_image_to_buffer(cl_device_id device, cl_context context,
+                                     cl_command_queue queue, int num_elements);
+extern int test_copy_buffer_rect(cl_device_id device, cl_context context,
+                                 cl_command_queue queue, int num_elements);
+extern int test_barrier_wait_list(cl_device_id device, cl_context context,
+                                  cl_command_queue queue, int num_elements);
 
 
 #endif /*_CL_KHR_COMMAND_BUFFER_PROCS_H*/