Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: correct variable naming 

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2023-11-29 15:57:54 +00:00 committed by Compute-Runtime-Automation
parent 61cbcf83ed
commit f2ede40d2e
6 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h
View File

@ -52,10 +52,10 @@ struct WhiteBox<::L0::CommandQueue> : public ::L0::CommandQueueImp {
};
using CommandQueue = WhiteBox<::L0::CommandQueue>;
static ze_command_queue_desc_t default_cmd_queue_desc = {};
static ze_command_queue_desc_t defaultCmdqueueDesc = {};
template <>
struct Mock<CommandQueue> : public CommandQueue {
Mock(L0::Device *device = nullptr, NEO::CommandStreamReceiver *csr = nullptr, const ze_command_queue_desc_t *desc = &default_cmd_queue_desc);
Mock(L0::Device *device = nullptr, NEO::CommandStreamReceiver *csr = nullptr, const ze_command_queue_desc_t *desc = &defaultCmdqueueDesc);
~Mock() override;
ADDMETHOD_NOBASE(createFence, ze_result_t, ZE_RESULT_SUCCESS, (const ze_fence_desc_t *desc, ze_fence_handle_t *phFence));

148
level_zero/core/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp
View File

@ -50,36 +50,36 @@ struct {
ze_sampler_handle_t hSamplerAPI;
void *instanceData0;
void *instanceData3;
} sampler_create_args;
} samplerCreateArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
WhenCallingSamplerCreateTracingWrapperWithTwoSetsOfPrologEpilogsCheckArgumentsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
sampler_create_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
sampler_create_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
sampler_create_args.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
samplerCreateArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
samplerCreateArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
samplerCreateArgs.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
// initialize replacement argument set
sampler_create_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
sampler_create_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
sampler_create_args.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
samplerCreateArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
samplerCreateArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
samplerCreateArgs.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
// initialize user instance data
sampler_create_args.instanceData0 = generateRandomHandle<void *>();
sampler_create_args.instanceData3 = generateRandomHandle<void *>();
samplerCreateArgs.instanceData0 = generateRandomHandle<void *>();
samplerCreateArgs.instanceData3 = generateRandomHandle<void *>();
// Arguments are expected to be passed in by the first prolog callback
driverDdiTable.coreDdiTable.Sampler.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) -> ze_result_t {
EXPECT_EQ(sampler_create_args.hContext1, hContext);
EXPECT_EQ(sampler_create_args.hDevice1, hDevice);
EXPECT_EQ(&sampler_create_args.desc1, pDesc);
EXPECT_EQ(&sampler_create_args.hSampler1, phSampler);
EXPECT_EQ(sampler_create_args.hSampler1, *phSampler);
sampler_create_args.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
*phSampler = sampler_create_args.hSamplerAPI;
EXPECT_EQ(samplerCreateArgs.hContext1, hContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, hDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, pDesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, phSampler);
EXPECT_EQ(samplerCreateArgs.hSampler1, *phSampler);
samplerCreateArgs.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
*phSampler = samplerCreateArgs.hSamplerAPI;
return ZE_RESULT_SUCCESS;
};
@ -89,10 +89,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs0.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext0, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice0, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc0, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler0, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext0, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice0, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc0, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler0, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -106,17 +106,17 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler0, handle);
*params->phContext = sampler_create_args.hContext1;
*params->phDevice = sampler_create_args.hDevice1;
*params->pdesc = &sampler_create_args.desc1;
*params->pphSampler = &sampler_create_args.hSampler1;
EXPECT_EQ(samplerCreateArgs.hSampler0, handle);
*params->phContext = samplerCreateArgs.hContext1;
*params->phDevice = samplerCreateArgs.hDevice1;
*params->pdesc = &samplerCreateArgs.desc1;
*params->pphSampler = &samplerCreateArgs.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData0;
instanceData->instanceDataValue = samplerCreateArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@ -128,10 +128,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -145,13 +145,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
EXPECT_EQ(samplerCreateArgs.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, samplerCreateArgs.instanceData0);
delete instanceData;
};
@ -161,10 +161,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs1.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -178,7 +178,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
EXPECT_EQ(samplerCreateArgs.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@ -192,10 +192,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
epilogCbs2.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -209,7 +209,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
EXPECT_EQ(samplerCreateArgs.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@ -222,10 +222,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs3.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -239,13 +239,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
EXPECT_EQ(samplerCreateArgs.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData3;
instanceData->instanceDataValue = samplerCreateArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@ -257,10 +257,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
EXPECT_EQ(samplerCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&samplerCreateArgs.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@ -274,21 +274,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
EXPECT_EQ(samplerCreateArgs.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, samplerCreateArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeSamplerCreateTracing(sampler_create_args.hContext0, sampler_create_args.hDevice0, &sampler_create_args.desc0, &sampler_create_args.hSampler0);
result = zeSamplerCreateTracing(samplerCreateArgs.hContext0, samplerCreateArgs.hDevice0, &samplerCreateArgs.desc0, &samplerCreateArgs.hSampler0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(sampler_create_args.hSampler1, sampler_create_args.hSamplerAPI);
EXPECT_EQ(samplerCreateArgs.hSampler1, samplerCreateArgs.hSamplerAPI);
validateDefaultUserDataFinal();
}
@ -297,26 +297,26 @@ struct {
ze_sampler_handle_t hSampler1;
void *instanceData0;
void *instanceData3;
} sampler_destroy_args;
} samplerDestroyArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
WhenCallingSamplerDestroyTracingWrapperWithTwoSetsOfPrologEpilogsCheckArgumentsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
sampler_destroy_args.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
samplerDestroyArgs.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
// initialize replacement argument set
sampler_destroy_args.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
samplerDestroyArgs.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
// initialize user instance data
sampler_destroy_args.instanceData0 = generateRandomHandle<void *>();
sampler_destroy_args.instanceData3 = generateRandomHandle<void *>();
samplerDestroyArgs.instanceData0 = generateRandomHandle<void *>();
samplerDestroyArgs.instanceData3 = generateRandomHandle<void *>();
// Arguments are expected to be passed in by the first prolog callback
driverDdiTable.coreDdiTable.Sampler.pfnDestroy =
[](ze_sampler_handle_t hSampler) -> ze_result_t {
EXPECT_EQ(sampler_destroy_args.hSampler1, hSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, hSampler);
return ZE_RESULT_SUCCESS;
};
@ -326,14 +326,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs0.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler0, *params->phSampler);
*params->phSampler = sampler_destroy_args.hSampler1;
EXPECT_EQ(samplerDestroyArgs.hSampler0, *params->phSampler);
*params->phSampler = samplerDestroyArgs.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData0;
instanceData->instanceDataValue = samplerDestroyArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@ -345,13 +345,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, samplerDestroyArgs.instanceData0);
delete instanceData;
};
@ -361,7 +361,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs1.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@ -375,7 +375,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
epilogCbs2.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@ -388,13 +388,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs3.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData3;
instanceData->instanceDataValue = samplerDestroyArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@ -406,19 +406,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
EXPECT_EQ(samplerDestroyArgs.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, samplerDestroyArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeSamplerDestroyTracing(sampler_destroy_args.hSampler0);
result = zeSamplerDestroyTracing(samplerDestroyArgs.hSampler0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

4
opencl/test/unit_test/command_queue/command_queue_fixture.h
View File

@ -73,7 +73,7 @@ struct CommandQueueFixture {
CommandQueue *pCmdQ = nullptr;
};
static const cl_command_queue_properties AllCommandQueueProperties[] = {
static const cl_command_queue_properties allCommandQueueProperties[] = {
0,
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
@ -82,7 +82,7 @@ static const cl_command_queue_properties AllCommandQueueProperties[] = {
CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE_DEFAULT};
static const cl_command_queue_properties DefaultCommandQueueProperties[] = {
static const cl_command_queue_properties defaultCommandQueueProperties[] = {
0,
CL_QUEUE_PROFILING_ENABLE,
};

2
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@ -130,7 +130,7 @@ TEST_P(CommandQueueTest, GivenNonFailingAllocationWhenCreatingCommandQueueThenCo
INSTANTIATE_TEST_CASE_P(CommandQueue,
CommandQueueTest,
::testing::ValuesIn(AllCommandQueueProperties));
::testing::ValuesIn(allCommandQueueProperties));
TEST(CommandQueue, WhenGettingErrorCodeFromTaskCountThenProperValueIsReturned) {
EXPECT_EQ(CL_SUCCESS, CommandQueue::getErrorCodeFromTaskCount(0));

2
opencl/test/unit_test/command_queue/get_command_queue_info_tests.cpp
View File

@ -123,7 +123,7 @@ TEST_P(GetCommandQueueInfoTest, GivenInvalidParameterWhenGettingCommandQueueInfo
INSTANTIATE_TEST_CASE_P(
GetCommandQueueInfoTest,
GetCommandQueueInfoTest,
::testing::ValuesIn(DefaultCommandQueueProperties));
::testing::ValuesIn(defaultCommandQueueProperties));
using GetCommandQueueFamilyInfoTests = ::testing::Test;

4
opencl/test/unit_test/mem_obj/image2d_tests.cpp
View File

@ -110,11 +110,11 @@ HWTEST_P(CreateImage2DType, GivenValidTypeWhenCreatingImageThenImageCreatedWithC
delete image;
}
static cl_mem_object_type Image2DTypes[] = {
static cl_mem_object_type image2DTypes[] = {
CL_MEM_OBJECT_IMAGE2D,
CL_MEM_OBJECT_IMAGE2D_ARRAY};
INSTANTIATE_TEST_CASE_P(
CreateImage2DTestCreate,
CreateImage2DType,
testing::ValuesIn(Image2DTypes));
testing::ValuesIn(image2DTypes));