refactor: correct variable naming

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h

@@ -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));

level_zero/core/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp

@@ -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>();
+    samplerCreateArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
-    sampler_create_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
+    samplerCreateArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
-    sampler_create_args.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
+    samplerCreateArgs.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
 
     // initialize replacement argument set
-    sampler_create_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
+    samplerCreateArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
-    sampler_create_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
+    samplerCreateArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
-    sampler_create_args.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
+    samplerCreateArgs.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
 
     // initialize user instance data
-    sampler_create_args.instanceData0 = generateRandomHandle<void *>();
+    samplerCreateArgs.instanceData0 = generateRandomHandle<void *>();
-    sampler_create_args.instanceData3 = 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(samplerCreateArgs.hContext1, hContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, hDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, hDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, pDesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, pDesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, phSampler);
+        EXPECT_EQ(&samplerCreateArgs.hSampler1, phSampler);
-        EXPECT_EQ(sampler_create_args.hSampler1, *phSampler);
+        EXPECT_EQ(samplerCreateArgs.hSampler1, *phSampler);
-        sampler_create_args.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
+        samplerCreateArgs.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
-        *phSampler = sampler_create_args.hSamplerAPI;
+        *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(samplerCreateArgs.hContext0, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice0, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice0, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc0, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc0, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler0, *params->pphSampler);
+        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);
+        EXPECT_EQ(samplerCreateArgs.hSampler0, handle);
-        *params->phContext = sampler_create_args.hContext1;
+        *params->phContext = samplerCreateArgs.hContext1;
-        *params->phDevice = sampler_create_args.hDevice1;
+        *params->phDevice = samplerCreateArgs.hDevice1;
-        *params->pdesc = &sampler_create_args.desc1;
+        *params->pdesc = &samplerCreateArgs.desc1;
-        *params->pphSampler = &sampler_create_args.hSampler1;
+        *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(samplerCreateArgs.hContext1, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+        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(samplerCreateArgs.hContext1, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+        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(samplerCreateArgs.hContext1, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+        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(samplerCreateArgs.hContext1, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+        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(samplerCreateArgs.hContext1, *params->phContext);
-        EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+        EXPECT_EQ(samplerCreateArgs.hDevice1, *params->phDevice);
-        EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
+        EXPECT_EQ(&samplerCreateArgs.desc1, *params->pdesc);
-        EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+        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 *>();
+    samplerDestroyArgs.instanceData0 = generateRandomHandle<void *>();
-    sampler_destroy_args.instanceData3 = 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);
+        EXPECT_EQ(samplerDestroyArgs.hSampler0, *params->phSampler);
-        *params->phSampler = sampler_destroy_args.hSampler1;
+        *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();
 }

opencl/test/unit_test/command_queue/command_queue_fixture.h

@@ -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,
 };

opencl/test/unit_test/command_queue/command_queue_tests.cpp

@@ -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));

opencl/test/unit_test/command_queue/get_command_queue_info_tests.cpp

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

opencl/test/unit_test/mem_obj/image2d_tests.cpp

@@ -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));