Skip to content

Commit 543c3ee

Browse files
Bogumil-Sapinski-MobicaBogumil-Sapinski-Mobica
committed
WiP unit tests
1 parent f867c0e commit 543c3ee

1 file changed

Lines changed: 244 additions & 125 deletions

File tree

‎tests/test_openclhpp.cpp‎

Lines changed: 244 additions & 125 deletions
Original file line numberDiff line numberDiff line change
@@ -356,36 +356,6 @@ MAKE_REFCOUNT_STUBS(cl_command_buffer_khr, clRetainCommandBufferKHR, clReleaseCo
356356
* macro value.
357357
*/
358358
#ifdef TEST_RVALUE_REFERENCES
359-
#ifdef KHR_NAMESPACE
360-
#define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \
361-
void prefix##MoveAssign##type##NonNull(void) { \
362-
releaseFunc##_ExpectAndReturn(makeFunc(0), CL_SUCCESS); \
363-
pool[0] = std::move(pool[1]); \
364-
TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
365-
TEST_ASSERT_NULL(pool[1]()); \
366-
} \
367-
\
368-
void prefix##MoveAssign##type##Null(void) { \
369-
pool[0]() = nullptr; \
370-
pool[0] = std::move(pool[1]); \
371-
TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
372-
TEST_ASSERT_NULL(pool[1]()); \
373-
} \
374-
\
375-
void prefix##MoveConstruct##type##NonNull(void) { \
376-
cl::khr::type tmp(std::move(pool[0])); \
377-
TEST_ASSERT_EQUAL_PTR(makeFunc(0), tmp()); \
378-
TEST_ASSERT_NULL(pool[0]()); \
379-
tmp() = nullptr; \
380-
} \
381-
\
382-
void prefix##MoveConstruct##type##Null(void) { \
383-
cl::khr::type empty; \
384-
cl::khr::type tmp(std::move(empty)); \
385-
TEST_ASSERT_NULL(tmp()); \
386-
TEST_ASSERT_NULL(empty()); \
387-
}
388-
#else
389359
#define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \
390360
void prefix##MoveAssign##type##NonNull(void) { \
391361
releaseFunc##_ExpectAndReturn(makeFunc(0), CL_SUCCESS); \
@@ -414,7 +384,6 @@ MAKE_REFCOUNT_STUBS(cl_command_buffer_khr, clRetainCommandBufferKHR, clReleaseCo
414384
TEST_ASSERT_NULL(tmp()); \
415385
TEST_ASSERT_NULL(empty()); \
416386
}
417-
#endif // KHR_NAMESPACE
418387
#else
419388
#define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \
420389
void prefix ## MoveAssign ## type ## NonNull(void) {} \
@@ -3493,100 +3462,127 @@ void testLinkProgramWithVectorProgramInput(void)
34933462
/****************************************************************************
34943463
* Tests for cl::khr::CommandBuffer
34953464
****************************************************************************/
3496-
#if defined(cl_khr_command_buffer)
3497-
void testMoveAssignCommandBufferKhrNonNull(void);
3498-
void testMoveAssignCommandBufferKhrNull(void);
3499-
void testMoveConstructCommandBufferKhrNonNull(void);
3500-
void testMoveConstructCommandBufferKhrNull(void);
3501-
#ifndef KHR_NAMESPACE
3502-
#define KHR_NAMESPACE
3503-
MAKE_MOVE_TESTS(CommandBuffer, make_command_buffer_khr,
3504-
clReleaseCommandBufferKHR, commandBufferKhrPool)
3505-
#undef KHR_NAMESPACE
3506-
#endif
3507-
#else
3508-
void testMoveAssignCommandBufferKhrNonNull(void) {}
3509-
void testMoveAssignCommandBufferKhrNull(void) {}
3510-
void testMoveConstructCommandBufferKhrNonNull(void) {}
3511-
void testMoveConstructCommandBufferKhrNull(void) {}
3512-
#endif
3513-
3514-
// Stub for clGetCommandBufferInfoKHR that returns 1
3515-
static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues(
3516-
cl_command_buffer_khr command_buffer,
3517-
cl_command_buffer_info_khr param_name,
3518-
size_t param_value_size,
3519-
void *param_value,
3520-
size_t *param_value_size_ret,
3521-
int /*num_calls*/)
3522-
{
3523-
TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
3524-
TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_NUM_QUEUES_KHR, param_name);
3525-
TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint));
3526-
if (param_value_size_ret != nullptr)
3527-
*param_value_size_ret = sizeof(cl_uint);
3528-
if (param_value != nullptr)
3529-
*static_cast<cl_uint *> (param_value) = 1;
3530-
return CL_SUCCESS;
3531-
}
3532-
3533-
void testCommandBufferInfoKHRNumQueues(void)
3534-
{
3535-
#if defined(cl_khr_command_buffer)
3536-
cl_uint expected = 1;
3537-
3538-
clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues);
3539-
3540-
cl_uint num = commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_NUM_QUEUES_KHR>();
3541-
TEST_ASSERT_EQUAL_HEX(expected, num);
3542-
#endif
3543-
}
3544-
3545-
// Stub for clGetCommandBufferInfoKHR that returns command queues array
3546-
static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues(
3547-
cl_command_buffer_khr command_buffer,
3548-
cl_command_buffer_info_khr param_name,
3549-
size_t param_value_size,
3550-
void *param_value,
3551-
size_t *param_value_size_ret,
3552-
int /*num_calls*/)
3553-
{
3554-
TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
3555-
TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_QUEUES_KHR, param_name);
3556-
TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl_command_queue));
3557-
if (param_value_size_ret != nullptr)
3558-
*param_value_size_ret = 3 * sizeof(cl_command_queue);
3559-
if (param_value != nullptr)
3560-
{
3561-
cl_command_queue *command_queues = static_cast<cl_command_queue *> (param_value);
3562-
command_queues[0] = make_command_queue(0);
3563-
command_queues[1] = make_command_queue(1);
3564-
command_queues[2] = make_command_queue(2);
3565-
}
3566-
return CL_SUCCESS;
3567-
}
3568-
3569-
void testCommandBufferInfoKHRCommandQueues(void)
3570-
{
3571-
#if defined(cl_khr_command_buffer)
3572-
// creat expected values for refcounter
3573-
VECTOR_CLASS<cl_command_queue> expected_queue_vec;
3574-
std::array<int, 3> refcount;
3575-
for (int i=0;i<3;i++) {
3576-
expected_queue_vec.push_back(commandQueuePool[i]());
3577-
refcount[i] = 1;
3578-
}
3579-
3580-
clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues);
3581-
prepare_commandQueueRefcounts(expected_queue_vec.size(), expected_queue_vec.data(), refcount.data());
3582-
3583-
VECTOR_CLASS<cl::CommandQueue> command_queues = commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_QUEUES_KHR>();
3584-
TEST_ASSERT_EQUAL(3, command_queues.size());
3585-
TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queues[0]());
3586-
TEST_ASSERT_EQUAL_PTR(make_command_queue(1), command_queues[1]());
3587-
TEST_ASSERT_EQUAL_PTR(make_command_queue(2), command_queues[2]());
3588-
#endif
3589-
}
3465+
// #if defined(cl_khr_command_buffer)
3466+
// void testMoveAssignCommandBufferKhrNonNull(void);
3467+
// void testMoveAssignCommandBufferKhrNull(void);
3468+
// void testMoveConstructCommandBufferKhrNonNull(void);
3469+
// void testMoveConstructCommandBufferKhrNull(void);
3470+
// #ifdef MAKE_MOVE_TESTS2
3471+
// #undef MAKE_MOVE_TESTS2
3472+
// #define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \
3473+
// void prefix##MoveAssign##type##NonNull(void) { \
3474+
// releaseFunc##_ExpectAndReturn(makeFunc(0), CL_SUCCESS); \
3475+
// pool[0] = std::move(pool[1]); \
3476+
// TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
3477+
// TEST_ASSERT_NULL(pool[1]()); \
3478+
// } \
3479+
// \
3480+
// void prefix##MoveAssign##type##Null(void) { \
3481+
// pool[0]() = nullptr; \
3482+
// pool[0] = std::move(pool[1]); \
3483+
// TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
3484+
// TEST_ASSERT_NULL(pool[1]()); \
3485+
// } \
3486+
// \
3487+
// void prefix##MoveConstruct##type##NonNull(void) { \
3488+
// cl::khr::type tmp(std::move(pool[0])); \
3489+
// TEST_ASSERT_EQUAL_PTR(makeFunc(0), tmp()); \
3490+
// TEST_ASSERT_NULL(pool[0]()); \
3491+
// tmp() = nullptr; \
3492+
// } \
3493+
// \
3494+
// void prefix##MoveConstruct##type##Null(void) { \
3495+
// cl::khr::type empty; \
3496+
// cl::khr::type tmp(std::move(empty)); \
3497+
// TEST_ASSERT_NULL(tmp()); \
3498+
// TEST_ASSERT_NULL(empty()); \
3499+
// }
3500+
// #endif
3501+
// MAKE_MOVE_TESTS(CommandBuffer, make_command_buffer_khr,
3502+
// clReleaseCommandBufferKHR, commandBufferKhrPool)
3503+
// #else
3504+
// void testMoveAssignCommandBufferKhrNonNull(void) {}
3505+
// void testMoveAssignCommandBufferKhrNull(void) {}
3506+
// void testMoveConstructCommandBufferKhrNonNull(void) {}
3507+
// void testMoveConstructCommandBufferKhrNull(void) {}
3508+
// #endif
3509+
3510+
// // Stub for clGetCommandBufferInfoKHR that returns 1
3511+
// static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues(
3512+
// cl_command_buffer_khr command_buffer,
3513+
// cl_command_buffer_info_khr param_name,
3514+
// size_t param_value_size,
3515+
// void *param_value,
3516+
// size_t *param_value_size_ret,
3517+
// int /*num_calls*/)
3518+
// {
3519+
// TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
3520+
// TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_NUM_QUEUES_KHR, param_name);
3521+
// TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint));
3522+
// if (param_value_size_ret != nullptr)
3523+
// *param_value_size_ret = sizeof(cl_uint);
3524+
// if (param_value != nullptr)
3525+
// *static_cast<cl_uint *> (param_value) = 1;
3526+
// return CL_SUCCESS;
3527+
// }
3528+
3529+
// void testCommandBufferInfoKHRNumQueues(void)
3530+
// {
3531+
// #if defined(cl_khr_command_buffer)
3532+
// cl_uint expected = 1;
3533+
3534+
// clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues);
3535+
3536+
// cl_uint num = commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_NUM_QUEUES_KHR>();
3537+
// TEST_ASSERT_EQUAL_HEX(expected, num);
3538+
// #endif
3539+
// }
3540+
3541+
// // Stub for clGetCommandBufferInfoKHR that returns command queues array
3542+
// static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues(
3543+
// cl_command_buffer_khr command_buffer,
3544+
// cl_command_buffer_info_khr param_name,
3545+
// size_t param_value_size,
3546+
// void *param_value,
3547+
// size_t *param_value_size_ret,
3548+
// int /*num_calls*/)
3549+
// {
3550+
// TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
3551+
// TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_QUEUES_KHR, param_name);
3552+
// TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl_command_queue));
3553+
// if (param_value_size_ret != nullptr)
3554+
// *param_value_size_ret = 3 * sizeof(cl_command_queue);
3555+
// if (param_value != nullptr)
3556+
// {
3557+
// cl_command_queue *command_queues = static_cast<cl_command_queue *> (param_value);
3558+
// command_queues[0] = make_command_queue(0);
3559+
// command_queues[1] = make_command_queue(1);
3560+
// command_queues[2] = make_command_queue(2);
3561+
// }
3562+
// return CL_SUCCESS;
3563+
// }
3564+
3565+
// void testCommandBufferInfoKHRCommandQueues(void)
3566+
// {
3567+
// #if defined(cl_khr_command_buffer)
3568+
// // creat expected values for refcounter
3569+
// VECTOR_CLASS<cl_command_queue> expected_queue_vec;
3570+
// std::array<int, 3> refcount;
3571+
// for (int i=0;i<3;i++) {
3572+
// expected_queue_vec.push_back(commandQueuePool[i]());
3573+
// refcount[i] = 1;
3574+
// }
3575+
3576+
// clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues);
3577+
// prepare_commandQueueRefcounts(expected_queue_vec.size(), expected_queue_vec.data(), refcount.data());
3578+
3579+
// VECTOR_CLASS<cl::CommandQueue> command_queues = commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_QUEUES_KHR>();
3580+
// TEST_ASSERT_EQUAL(3, command_queues.size());
3581+
// TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queues[0]());
3582+
// TEST_ASSERT_EQUAL_PTR(make_command_queue(1), command_queues[1]());
3583+
// TEST_ASSERT_EQUAL_PTR(make_command_queue(2), command_queues[2]());
3584+
// #endif
3585+
// }
35903586
// Tests for Device::GetInfo
35913587
static cl_int clGetInfo_testDeviceGetInfoCLDeviceVendorId(
35923588
cl_device_id device, cl_device_info param_name, size_t param_value_size,
@@ -4420,4 +4416,127 @@ void testTemplateGetImageRequirementsInfo()
44204416
void testTemplateGetImageRequirementsInfo() {}
44214417
#endif // cl_ext_image_requirements_info
44224418

4419+
/****************************************************************************
4420+
* Tests for cl::khr::CommandBuffer
4421+
* Please put above any tests of functionalities defined in cl namespace.
4422+
* Some macros where redifined with cl::khr namespace.
4423+
****************************************************************************/
4424+
#if defined(cl_khr_command_buffer)
4425+
void testMoveAssignCommandBufferKhrNonNull(void);
4426+
void testMoveAssignCommandBufferKhrNull(void);
4427+
void testMoveConstructCommandBufferKhrNonNull(void);
4428+
void testMoveConstructCommandBufferKhrNull(void);
4429+
#ifdef MAKE_MOVE_TESTS2
4430+
#undef MAKE_MOVE_TESTS2
4431+
#define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \
4432+
void prefix##MoveAssign##type##NonNull(void) { \
4433+
releaseFunc##_ExpectAndReturn(makeFunc(0), CL_SUCCESS); \
4434+
pool[0] = std::move(pool[1]); \
4435+
TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
4436+
TEST_ASSERT_NULL(pool[1]()); \
4437+
} \
4438+
\
4439+
void prefix##MoveAssign##type##Null(void) { \
4440+
pool[0]() = nullptr; \
4441+
pool[0] = std::move(pool[1]); \
4442+
TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \
4443+
TEST_ASSERT_NULL(pool[1]()); \
4444+
} \
4445+
\
4446+
void prefix##MoveConstruct##type##NonNull(void) { \
4447+
cl::khr::type tmp(std::move(pool[0])); \
4448+
TEST_ASSERT_EQUAL_PTR(makeFunc(0), tmp()); \
4449+
TEST_ASSERT_NULL(pool[0]()); \
4450+
tmp() = nullptr; \
4451+
} \
4452+
\
4453+
void prefix##MoveConstruct##type##Null(void) { \
4454+
cl::khr::type empty; \
4455+
cl::khr::type tmp(std::move(empty)); \
4456+
TEST_ASSERT_NULL(tmp()); \
4457+
TEST_ASSERT_NULL(empty()); \
4458+
}
4459+
#endif
4460+
MAKE_MOVE_TESTS(CommandBuffer, make_command_buffer_khr,
4461+
clReleaseCommandBufferKHR, commandBufferKhrPool)
4462+
#else
4463+
void testMoveAssignCommandBufferKhrNonNull(void) {}
4464+
void testMoveAssignCommandBufferKhrNull(void) {}
4465+
void testMoveConstructCommandBufferKhrNonNull(void) {}
4466+
void testMoveConstructCommandBufferKhrNull(void) {}
4467+
#endif
4468+
4469+
// Stub for clGetCommandBufferInfoKHR that returns 1
4470+
static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues(
4471+
cl_command_buffer_khr command_buffer, cl_command_buffer_info_khr param_name,
4472+
size_t param_value_size, void *param_value, size_t *param_value_size_ret,
4473+
int /*num_calls*/) {
4474+
TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
4475+
TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_NUM_QUEUES_KHR, param_name);
4476+
TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint));
4477+
if (param_value_size_ret != nullptr)
4478+
*param_value_size_ret = sizeof(cl_uint);
4479+
if (param_value != nullptr)
4480+
*static_cast<cl_uint *>(param_value) = 1;
4481+
return CL_SUCCESS;
4482+
}
4483+
4484+
void testCommandBufferInfoKHRNumQueues(void) {
4485+
#if defined(cl_khr_command_buffer)
4486+
cl_uint expected = 1;
4487+
4488+
clGetCommandBufferInfoKHR_StubWithCallback(
4489+
clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues);
4490+
4491+
cl_uint num =
4492+
commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_NUM_QUEUES_KHR>();
4493+
TEST_ASSERT_EQUAL_HEX(expected, num);
4494+
#endif
4495+
}
4496+
4497+
// Stub for clGetCommandBufferInfoKHR that returns command queues array
4498+
static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues(
4499+
cl_command_buffer_khr command_buffer, cl_command_buffer_info_khr param_name,
4500+
size_t param_value_size, void *param_value, size_t *param_value_size_ret,
4501+
int /*num_calls*/) {
4502+
TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer);
4503+
TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_QUEUES_KHR, param_name);
4504+
TEST_ASSERT(param_value == nullptr ||
4505+
param_value_size >= 3 * sizeof(cl_command_queue));
4506+
if (param_value_size_ret != nullptr)
4507+
*param_value_size_ret = 3 * sizeof(cl_command_queue);
4508+
if (param_value != nullptr) {
4509+
cl_command_queue *command_queues =
4510+
static_cast<cl_command_queue *>(param_value);
4511+
command_queues[0] = make_command_queue(0);
4512+
command_queues[1] = make_command_queue(1);
4513+
command_queues[2] = make_command_queue(2);
4514+
}
4515+
return CL_SUCCESS;
4516+
}
4517+
4518+
void testCommandBufferInfoKHRCommandQueues(void) {
4519+
#if defined(cl_khr_command_buffer)
4520+
// creat expected values for refcounter
4521+
VECTOR_CLASS<cl_command_queue> expected_queue_vec;
4522+
std::array<int, 3> refcount;
4523+
for (int i = 0; i < 3; i++) {
4524+
expected_queue_vec.push_back(commandQueuePool[i]());
4525+
refcount[i] = 1;
4526+
}
4527+
4528+
clGetCommandBufferInfoKHR_StubWithCallback(
4529+
clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues);
4530+
prepare_commandQueueRefcounts(expected_queue_vec.size(),
4531+
expected_queue_vec.data(), refcount.data());
4532+
4533+
VECTOR_CLASS<cl::CommandQueue> command_queues =
4534+
commandBufferKhrPool[0].getInfo<CL_COMMAND_BUFFER_QUEUES_KHR>();
4535+
TEST_ASSERT_EQUAL(3, command_queues.size());
4536+
TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queues[0]());
4537+
TEST_ASSERT_EQUAL_PTR(make_command_queue(1), command_queues[1]());
4538+
TEST_ASSERT_EQUAL_PTR(make_command_queue(2), command_queues[2]());
4539+
#endif
4540+
}
4541+
44234542
} // extern "C"

0 commit comments

Comments
 (0)