Migrate extensions suites to the new test registration framework (#2334)

This covers:
* cl_ext_cxx_for_opencl
* cl_khr_command_buffer
* cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch
* cl_khr_dx9_media_sharing
* cl_khr_external_semaphore
* cl_khr_kernel_clock
* cl_khr_semaphore

Contributes to #2181.

---------

Signed-off-by: Ahmed Hesham <ahmed.hesham@arm.com>

test_conformance/extensions/cl_khr_semaphore/main.cpp

@@ -13,71 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-#include "harness/compat.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <string.h>
-#include "procs.h"
 #include "harness/testHarness.h"
 
-#if !defined(_WIN32)
-#include <unistd.h>
-#endif
-
-test_definition test_list[] = {
-    ADD_TEST_VERSION(semaphores_simple_1, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_simple_2, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_reuse, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_cross_queues_ooo, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_cross_queues_io, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_multi_signal, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_multi_wait, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_device_list_queries, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_no_device_list_queries, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_multi_device_context_queries, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_ooo_ops_single_queue, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_ooo_ops_cross_queue, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_invalid_context, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_invalid_property,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_multi_device_property,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_invalid_device, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_import_invalid_device,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_invalid_value, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_create_invalid_operation,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_get_info_invalid_semaphore,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_get_info_invalid_value, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_command_queue,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_value, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_semaphore, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_context, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_event_wait_list,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_wait_invalid_event_status,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_command_queue,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_value, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_semaphore,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_context, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_event_wait_list,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_signal_invalid_event_status,
-                     Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_release, Version(1, 2)),
-    ADD_TEST_VERSION(semaphores_negative_retain, Version(1, 2)),
-};
-
-const int test_num = ARRAY_SIZE(test_list);
-
 int main(int argc, const char *argv[])
 {
-    return runTestHarness(argc, argv, test_num, test_list, false, 0);
+    return runTestHarness(argc, argv, test_registry::getInstance().num_tests(),
+                          test_registry::getInstance().definitions(), false, 0);
 }

test_conformance/extensions/cl_khr_semaphore/procs.h

@@ -1,140 +0,0 @@
-//
-// Copyright (c) 2023 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 "harness/errorHelpers.h"
-#include "harness/kernelHelpers.h"
-#include "harness/typeWrappers.h"
-#include "harness/clImageHelper.h"
-#include "harness/imageHelpers.h"
-
-extern int test_semaphores_simple_1(cl_device_id deviceID, cl_context context,
-                                    cl_command_queue queue, int num_elements);
-extern int test_semaphores_simple_2(cl_device_id deviceID, cl_context context,
-                                    cl_command_queue queue, int num_elements);
-extern int test_semaphores_reuse(cl_device_id deviceID, cl_context context,
-                                 cl_command_queue queue, int num_elements);
-extern int test_semaphores_cross_queues_ooo(cl_device_id deviceID,
-                                            cl_context context,
-                                            cl_command_queue queue,
-                                            int num_elements);
-extern int test_semaphores_cross_queues_io(cl_device_id deviceID,
-                                           cl_context context,
-                                           cl_command_queue queue,
-                                           int num_elements);
-extern int test_semaphores_multi_signal(cl_device_id deviceID,
-                                        cl_context context,
-                                        cl_command_queue queue,
-                                        int num_elements);
-extern int test_semaphores_multi_wait(cl_device_id deviceID, cl_context context,
-                                      cl_command_queue queue, int num_elements);
-extern int test_semaphores_device_list_queries(cl_device_id deviceID,
-                                               cl_context context,
-                                               cl_command_queue queue,
-                                               int num_elements);
-extern int test_semaphores_no_device_list_queries(cl_device_id deviceID,
-                                                  cl_context context,
-                                                  cl_command_queue queue,
-                                                  int num_elements);
-extern int test_semaphores_multi_device_context_queries(cl_device_id deviceID,
-                                                        cl_context context,
-                                                        cl_command_queue queue,
-                                                        int num_elements);
-extern int test_semaphores_import_export_fd(cl_device_id deviceID,
-                                            cl_context context,
-                                            cl_command_queue queue,
-                                            int num_elements);
-extern int test_semaphores_negative_create_invalid_context(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_create_invalid_property(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_create_multi_device_property(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_create_invalid_device(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_create_import_invalid_device(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_create_invalid_value(cl_device_id device,
-                                                         cl_context context,
-                                                         cl_command_queue queue,
-                                                         int num_elements);
-extern int test_semaphores_negative_create_invalid_operation(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_get_info_invalid_semaphore(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_get_info_invalid_value(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_wait_invalid_command_queue(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_wait_invalid_value(cl_device_id device,
-                                                       cl_context context,
-                                                       cl_command_queue queue,
-                                                       int num_elements);
-extern int test_semaphores_negative_wait_invalid_semaphore(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_wait_invalid_context(cl_device_id device,
-                                                         cl_context context,
-                                                         cl_command_queue queue,
-                                                         int num_elements);
-extern int test_semaphores_negative_wait_invalid_event_wait_list(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_wait_invalid_event_status(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_signal_invalid_command_queue(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_signal_invalid_value(cl_device_id device,
-                                                         cl_context context,
-                                                         cl_command_queue queue,
-                                                         int num_elements);
-extern int test_semaphores_negative_signal_invalid_semaphore(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_signal_invalid_context(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_signal_invalid_event_wait_list(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_signal_invalid_event_status(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements);
-extern int test_semaphores_negative_release(cl_device_id device,
-                                            cl_context context,
-                                            cl_command_queue queue,
-                                            int num_elements);
-extern int test_semaphores_negative_retain(cl_device_id device,
-                                           cl_context context,
-                                           cl_command_queue queue,
-                                           int num_elements);
-extern int test_semaphores_ooo_ops_single_queue(cl_device_id deviceID,
-                                                cl_context context,
-                                                cl_command_queue defaultQueue,
-                                                int num_elements);
-extern int test_semaphores_ooo_ops_cross_queue(cl_device_id deviceID,
-                                               cl_context context,
-                                               cl_command_queue defaultQueue,
-                                               int num_elements);

test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp

@@ -381,43 +381,36 @@ struct SemaphoreMultiWait : public SemaphoreTestBase
 } // anonymous namespace
 
 // Confirm that a signal followed by a wait will complete successfully
-int test_semaphores_simple_1(cl_device_id deviceID, cl_context context,
-                             cl_command_queue defaultQueue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_simple_1, Version(1, 2))
 {
-    return MakeAndRunTest<SimpleSemaphore1>(deviceID, context, defaultQueue,
+    return MakeAndRunTest<SimpleSemaphore1>(device, context, queue,
                                             num_elements);
 }
 
 // Confirm that signal a semaphore with no event dependencies will not result
 // in an implicit dependency on everything previously submitted
-int test_semaphores_simple_2(cl_device_id deviceID, cl_context context,
-                             cl_command_queue defaultQueue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_simple_2, Version(1, 2))
 {
-    return MakeAndRunTest<SimpleSemaphore2>(deviceID, context, defaultQueue,
+    return MakeAndRunTest<SimpleSemaphore2>(device, context, queue,
                                             num_elements);
 }
 
 // Confirm that a semaphore can be reused multiple times
-int test_semaphores_reuse(cl_device_id deviceID, cl_context context,
-                          cl_command_queue defaultQueue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_reuse, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreReuse>(deviceID, context, defaultQueue,
-                                          num_elements);
+    return MakeAndRunTest<SemaphoreReuse>(device, context, queue, num_elements);
 }
 
 // Confirm that we can signal multiple semaphores with one command
-int test_semaphores_multi_signal(cl_device_id deviceID, cl_context context,
-                                 cl_command_queue defaultQueue,
-                                 int num_elements)
+REGISTER_TEST_VERSION(semaphores_multi_signal, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreMultiSignal>(deviceID, context, defaultQueue,
+    return MakeAndRunTest<SemaphoreMultiSignal>(device, context, queue,
                                                 num_elements);
 }
 
 // Confirm that we can wait for multiple semaphores with one command
-int test_semaphores_multi_wait(cl_device_id deviceID, cl_context context,
-                               cl_command_queue defaultQueue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_multi_wait, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreMultiWait>(deviceID, context, defaultQueue,
+    return MakeAndRunTest<SemaphoreMultiWait>(device, context, queue,
                                               num_elements);
 }

test_conformance/extensions/cl_khr_semaphore/test_semaphores_cross_queue.cpp

@@ -312,41 +312,31 @@ struct SemaphoreOutOfOrderOps : public SemaphoreTestBase
 } // anonymous namespace
 
 // Confirm that a semaphore works across different ooo queues
-int test_semaphores_cross_queues_ooo(cl_device_id deviceID, cl_context context,
-                                     cl_command_queue defaultQueue,
-                                     int num_elements)
+REGISTER_TEST_VERSION(semaphores_cross_queues_ooo, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreCrossQueue<false>>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreCrossQueue<false>>(device, context, queue,
+                                                      num_elements);
 }
 
 // Confirm that a semaphore works across different in-order queues
-int test_semaphores_cross_queues_io(cl_device_id deviceID, cl_context context,
-                                    cl_command_queue defaultQueue,
-                                    int num_elements)
+REGISTER_TEST_VERSION(semaphores_cross_queues_io, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreCrossQueue<true>>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreCrossQueue<true>>(device, context, queue,
+                                                     num_elements);
 }
 
 // Confirm that we can synchronize signal/wait commands in single out-of-order
 // queue
-int test_semaphores_ooo_ops_single_queue(cl_device_id deviceID,
-                                         cl_context context,
-                                         cl_command_queue defaultQueue,
-                                         int num_elements)
+REGISTER_TEST_VERSION(semaphores_ooo_ops_single_queue, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreOutOfOrderOps<true>>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreOutOfOrderOps<true>>(device, context, queue,
+                                                        num_elements);
 }
 
 // Confirm that we can synchronize signal/wait commands across two out-of-order
 // queues
-int test_semaphores_ooo_ops_cross_queue(cl_device_id deviceID,
-                                        cl_context context,
-                                        cl_command_queue defaultQueue,
-                                        int num_elements)
+REGISTER_TEST_VERSION(semaphores_ooo_ops_cross_queue, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreOutOfOrderOps<false>>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreOutOfOrderOps<false>>(device, context, queue,
+                                                         num_elements);
 }

test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_create.cpp

@@ -679,10 +679,7 @@ struct CreateInvalidOperation : public SemaphoreTestBase
 
 // Confirm that creation semaphore with nullptr context would return
 // CL_INVALID_CONTEXT
-int test_semaphores_negative_create_invalid_context(cl_device_id device,
-                                                    cl_context context,
-                                                    cl_command_queue queue,
-                                                    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_invalid_context, Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidContext>(device, context, queue,
                                                 num_elements);
@@ -690,10 +687,8 @@ int test_semaphores_negative_create_invalid_context(cl_device_id device,
 
 // Confirm that creation semaphore with invalid properties return
 // CL_INVALID_PROPERTY
-int test_semaphores_negative_create_invalid_property(cl_device_id device,
-                                                     cl_context context,
-                                                     cl_command_queue queue,
-                                                     int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_invalid_property,
+                      Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidProperty>(device, context, queue,
                                                  num_elements);
@@ -701,9 +696,8 @@ int test_semaphores_negative_create_invalid_property(cl_device_id device,
 
 // Confirm that creation semaphore with multi device property return
 // CL_INVALID_PROPERTY
-int test_semaphores_negative_create_multi_device_property(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_multi_device_property,
+                      Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidMultiDeviceProperty>(
         device, context, queue, num_elements);
@@ -711,10 +705,7 @@ int test_semaphores_negative_create_multi_device_property(
 
 // Confirm that creation semaphore with invalid device(s) return
 // CL_INVALID_DEVICE
-int test_semaphores_negative_create_invalid_device(cl_device_id device,
-                                                   cl_context context,
-                                                   cl_command_queue queue,
-                                                   int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_invalid_device, Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidDevice>(device, context, queue,
                                                num_elements);
@@ -722,9 +713,8 @@ int test_semaphores_negative_create_invalid_device(cl_device_id device,
 
 // Confirm that creation semaphore with invalid device(s) return
 // CL_INVALID_DEVICE
-int test_semaphores_negative_create_import_invalid_device(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_import_invalid_device,
+                      Version(1, 2))
 {
     return MakeAndRunTest<CreateImportExternalWithInvalidDevice>(
         device, context, queue, num_elements);
@@ -732,10 +722,7 @@ int test_semaphores_negative_create_import_invalid_device(
 
 // Confirm that creation semaphore with invalid props values return
 // CL_INVALID_VALUE
-int test_semaphores_negative_create_invalid_value(cl_device_id device,
-                                                  cl_context context,
-                                                  cl_command_queue queue,
-                                                  int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_invalid_value, Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidValue>(device, context, queue,
                                               num_elements);
@@ -743,10 +730,8 @@ int test_semaphores_negative_create_invalid_value(cl_device_id device,
 
 // Confirm that creation semaphore with invalid props values return
 // CL_INVALID_VALUE
-int test_semaphores_negative_create_invalid_operation(cl_device_id device,
-                                                      cl_context context,
-                                                      cl_command_queue queue,
-                                                      int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_create_invalid_operation,
+                      Version(1, 2))
 {
     return MakeAndRunTest<CreateInvalidOperation>(device, context, queue,
                                                   num_elements);

test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_getinfo.cpp

@@ -113,19 +113,14 @@ struct GetInfoInvalidValue : public SemaphoreTestBase
 
 }
 
-int test_semaphores_negative_get_info_invalid_semaphore(cl_device_id device,
-                                                        cl_context context,
-                                                        cl_command_queue queue,
-                                                        int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_get_info_invalid_semaphore,
+                      Version(1, 2))
 {
     return MakeAndRunTest<GetInfoInvalidSemaphore>(device, context, queue,
                                                    num_elements);
 }
 
-int test_semaphores_negative_get_info_invalid_value(cl_device_id device,
-                                                    cl_context context,
-                                                    cl_command_queue queue,
-                                                    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_get_info_invalid_value, Version(1, 2))
 {
     return MakeAndRunTest<GetInfoInvalidValue>(device, context, queue,
                                                num_elements);

test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_release_retain.cpp

@@ -76,15 +76,13 @@ struct RetainInvalidSemaphore : public SemaphoreTestBase
 
 }
 
-int test_semaphores_negative_release(cl_device_id device, cl_context context,
-                                     cl_command_queue queue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_release, Version(1, 2))
 {
     return MakeAndRunTest<ReleaseInvalidSemaphore>(device, context, queue,
                                                    num_elements);
 }
 
-int test_semaphores_negative_retain(cl_device_id device, cl_context context,
-                                    cl_command_queue queue, int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_retain, Version(1, 2))
 {
     return MakeAndRunTest<RetainInvalidSemaphore>(device, context, queue,
                                                   num_elements);

test_conformance/extensions/cl_khr_semaphore/test_semaphores_negative_wait_signal.cpp

@@ -494,106 +494,80 @@ template <RunMode mode> struct InvalidEventStatus : public SemaphoreTestBase
 
 }
 
-int test_semaphores_negative_wait_invalid_command_queue(cl_device_id device,
-                                                        cl_context context,
-                                                        cl_command_queue queue,
-                                                        int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_command_queue,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidCommandQueue<RunMode::RM_WAIT>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_wait_invalid_value(cl_device_id device,
-                                                cl_context context,
-                                                cl_command_queue queue,
-                                                int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_value, Version(1, 2))
 {
     return MakeAndRunTest<InvalidValue<RunMode::RM_WAIT>>(device, context,
                                                           queue, num_elements);
 }
 
-int test_semaphores_negative_wait_invalid_semaphore(cl_device_id device,
-                                                    cl_context context,
-                                                    cl_command_queue queue,
-                                                    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_semaphore, Version(1, 2))
 {
     return MakeAndRunTest<InvalidSemaphore<RunMode::RM_WAIT>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_wait_invalid_context(cl_device_id device,
-                                                  cl_context context,
-                                                  cl_command_queue queue,
-                                                  int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_context, Version(1, 2))
 {
     return MakeAndRunTest<InvalidContext<RunMode::RM_WAIT>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_wait_invalid_event_wait_list(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_event_wait_list,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidEventWaitList<RunMode::RM_WAIT>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_wait_invalid_event_status(cl_device_id device,
-                                                       cl_context context,
-                                                       cl_command_queue queue,
-                                                       int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_wait_invalid_event_status,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidEventStatus<RunMode::RM_WAIT>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_command_queue(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_command_queue,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidCommandQueue<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_value(cl_device_id device,
-                                                  cl_context context,
-                                                  cl_command_queue queue,
-                                                  int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_value, Version(1, 2))
 {
     return MakeAndRunTest<InvalidValue<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_semaphore(cl_device_id device,
-                                                      cl_context context,
-                                                      cl_command_queue queue,
-                                                      int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_semaphore,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidSemaphore<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_context(cl_device_id device,
-                                                    cl_context context,
-                                                    cl_command_queue queue,
-                                                    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_context, Version(1, 2))
 {
     return MakeAndRunTest<InvalidContext<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_event_wait_list(
-    cl_device_id device, cl_context context, cl_command_queue queue,
-    int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_event_wait_list,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidEventWaitList<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);
 }
 
-int test_semaphores_negative_signal_invalid_event_status(cl_device_id device,
-                                                         cl_context context,
-                                                         cl_command_queue queue,
-                                                         int num_elements)
+REGISTER_TEST_VERSION(semaphores_negative_signal_invalid_event_status,
+                      Version(1, 2))
 {
     return MakeAndRunTest<InvalidEventStatus<RunMode::RM_SIGNAL>>(
         device, context, queue, num_elements);

test_conformance/extensions/cl_khr_semaphore/test_semaphores_queries.cpp

@@ -255,32 +255,23 @@ struct SemaphoreMultiDeviceContextQueries : public SemaphoreTestBase
 } // anonymous namespace
 
 // Confirm the semaphore with device list can be successfully queried
-int test_semaphores_device_list_queries(cl_device_id deviceID,
-                                        cl_context context,
-                                        cl_command_queue defaultQueue,
-                                        int num_elements)
+REGISTER_TEST_VERSION(semaphores_device_list_queries, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreWithDeviceListQueries>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreWithDeviceListQueries>(device, context,
+                                                          queue, num_elements);
 }
 
 // Confirm the semaphore without device list can be successfully queried
-int test_semaphores_no_device_list_queries(cl_device_id deviceID,
-                                           cl_context context,
-                                           cl_command_queue defaultQueue,
-                                           int num_elements)
+REGISTER_TEST_VERSION(semaphores_no_device_list_queries, Version(1, 2))
 {
-    return MakeAndRunTest<SemaphoreNoDeviceListQueries>(
-        deviceID, context, defaultQueue, num_elements);
+    return MakeAndRunTest<SemaphoreNoDeviceListQueries>(device, context, queue,
+                                                        num_elements);
 }
 
 // Confirm the semaphore created with multi-device context can be successfully
 // queried
-int test_semaphores_multi_device_context_queries(cl_device_id deviceID,
-                                                 cl_context context,
-                                                 cl_command_queue defaultQueue,
-                                                 int num_elements)
+REGISTER_TEST_VERSION(semaphores_multi_device_context_queries, Version(1, 2))
 {
     return MakeAndRunTest<SemaphoreMultiDeviceContextQueries>(
-        deviceID, context, defaultQueue, num_elements);
+        device, context, queue, num_elements);
 }