refactor: correct variable naming

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

opencl/test/unit_test/aub_tests/command_queue/enqueue_kernel_aub_tests.cpp

@@ -34,7 +34,7 @@ struct TestParam {
     cl_uint localWorkSizeZ;
 };
 
-static TestParam TestParamTable[] = {
+static TestParam testParamTable[] = {
     {1, 1, 1, 1, 1, 1},
     {16, 1, 1, 16, 1, 1},
     {32, 1, 1, 16, 1, 1},
@@ -42,7 +42,7 @@ static TestParam TestParamTable[] = {
     {64, 1, 1, 16, 1, 1},
     {64, 1, 1, 64, 1, 1}};
 
-cl_uint TestSimdTable[] = {
+cl_uint testSimdTable[] = {
     8, 16, 32};
 
 namespace ULT {
@@ -255,8 +255,8 @@ INSTANTIATE_TEST_CASE_P(
     AUB,
     AUBHelloWorldIntegrateTest,
     ::testing::Combine(
-        ::testing::ValuesIn(TestSimdTable),
+        ::testing::ValuesIn(testSimdTable),
-        ::testing::ValuesIn(TestParamTable)));
+        ::testing::ValuesIn(testParamTable)));
 
 struct AUBSimpleArg
     : public SimpleArgFixture<AUBSimpleArgFixtureFactory>,
@@ -423,8 +423,8 @@ INSTANTIATE_TEST_CASE_P(
     AUB,
     AUBSimpleArgIntegrateTest,
     ::testing::Combine(
-        ::testing::ValuesIn(TestSimdTable),
+        ::testing::ValuesIn(testSimdTable),
-        ::testing::ValuesIn(TestParamTable)));
+        ::testing::ValuesIn(testParamTable)));
 } // namespace ULT
 
 struct AUBSimpleArgNonUniformFixture : public KernelAUBFixture<SimpleArgNonUniformKernelFixture> {

opencl/test/unit_test/aub_tests/command_stream/aub_walker_partition_tests_xehp_and_later.cpp

@@ -36,10 +36,10 @@ static uint32_t testWorkingDimensions[] = {3};
 
 extern bool generateRandomInput;
 
-struct DispatchParamters {
+struct DispatchParameters {
     size_t globalWorkSize[3];
     size_t localWorkSize[3];
-} DispatchParamtersForTests[] = {
+} dispatchParametersForTests[] = {
     {{12, 25, 21}, {3, 5, 7}},
     {{8, 16, 20}, {8, 4, 2}},
     {{7, 13, 17}, {1, 1, 1}},
@@ -157,11 +157,11 @@ struct AubWalkerPartitionFixture : public KernelAUBFixture<SimpleKernelFixture>
     int32_t partitionType;
 
     HardwareParse hwParser;
-    DispatchParamters dispatchParamters;
+    DispatchParameters dispatchParamters;
 };
 
 struct AubWalkerPartitionTest : public AubWalkerPartitionFixture,
-                                public ::testing::TestWithParam<std::tuple<int32_t, int32_t, DispatchParamters, uint32_t>> {
+                                public ::testing::TestWithParam<std::tuple<int32_t, int32_t, DispatchParameters, uint32_t>> {
     void SetUp() override {
         AubWalkerPartitionFixture::setUp();
         std::tie(partitionCount, partitionType, dispatchParamters, workingDimensions) = GetParam();
@@ -1187,7 +1187,7 @@ INSTANTIATE_TEST_CASE_P(
     ::testing::Combine(
         ::testing::ValuesIn(testPartitionCount),
         ::testing::ValuesIn(testPartitionType),
-        ::testing::ValuesIn(DispatchParamtersForTests),
+        ::testing::ValuesIn(dispatchParametersForTests),
         ::testing::ValuesIn(testWorkingDimensions)));
 
 using AubWparidTests = Test<AubWalkerPartitionFixture>;

opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp

@@ -36,7 +36,7 @@ using namespace NEO;
 
 struct TestParam2 {
     uint32_t scratchSize;
-} TestParamTable2[] = {{1024u}, {2048u}, {4096u}, {8192u}, {16384u}};
+} testParamTable2[] = {{1024u}, {2048u}, {4096u}, {8192u}, {16384u}};
 
 struct TestParam {
     cl_uint globalWorkSizeX;
@@ -45,7 +45,7 @@ struct TestParam {
     cl_uint localWorkSizeX;
     cl_uint localWorkSizeY;
     cl_uint localWorkSizeZ;
-} TestParamTable[] = {
+} testParamTable[] = {
     {1, 1, 1, 1, 1, 1},
     {16, 1, 1, 1, 1, 1},
     {16, 1, 1, 16, 1, 1},
@@ -59,7 +59,7 @@ struct TestParam {
     {190, 1, 1, 95, 1, 1},
     {510, 1, 1, 255, 1, 1},
     {512, 1, 1, 256, 1, 1}},
-  OneEntryTestParamTable[] = {
+  oneEntryTestParamTable[] = {
       {1, 1, 1, 1, 1, 1},
 };
 template <typename InputType>
@@ -296,11 +296,11 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTestsWithLimitedParamSet, WhenEnquein
 
 INSTANTIATE_TEST_CASE_P(EnqueueKernel,
                         EnqueueWorkItemTests,
-                        ::testing::ValuesIn(TestParamTable));
+                        ::testing::ValuesIn(testParamTable));
 
 INSTANTIATE_TEST_CASE_P(EnqueueKernel,
                         EnqueueWorkItemTestsWithLimitedParamSet,
-                        ::testing::ValuesIn(OneEntryTestParamTable));
+                        ::testing::ValuesIn(oneEntryTestParamTable));
 
 typedef EnqueueKernelTypeTest<TestParam2> EnqueueScratchSpaceTests;
 
@@ -439,7 +439,7 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueScratchSpaceTests, GivenKernelRequiringScratc
 
 INSTANTIATE_TEST_CASE_P(EnqueueKernel,
                         EnqueueScratchSpaceTests,
-                        ::testing::ValuesIn(TestParamTable2));
+                        ::testing::ValuesIn(testParamTable2));
 
 typedef EnqueueKernelTypeTest<int> EnqueueKernelWithScratch;
 
@@ -531,7 +531,7 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelWithScratch, givenDeviceForcing32bitAll
 INSTANTIATE_TEST_CASE_P(EnqueueKernel,
                         EnqueueKernelWithScratch, testing::Values(1));
 
-TestParam TestParamPrintf[] = {
+TestParam testParamPrintf[] = {
     {1, 1, 1, 1, 1, 1}};
 
 typedef EnqueueKernelTypeTest<TestParam> EnqueueKernelPrintfTest;
@@ -721,7 +721,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWithStringMapDisbaledAndI
 
 INSTANTIATE_TEST_CASE_P(EnqueueKernel,
                         EnqueueKernelPrintfTest,
-                        ::testing::ValuesIn(TestParamPrintf));
+                        ::testing::ValuesIn(testParamPrintf));
 
 using EnqueueKernelTests = ::testing::Test;
 

opencl/test/unit_test/command_queue/enqueue_waitlist_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2022 Intel Corporation
+ * Copyright (C) 2018-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -221,14 +221,14 @@ TEST_P(EnqueueWaitlistTest, GivenCompletedUserEventOnWaitlistWhenFinishingComman
     testError(error, "Finish FAILED");
 }
 
-ExecuteEnqueue Enqueues[] =
+ExecuteEnqueue enqueues[] =
     {
         &EnqueueWaitlistTest::enqueueNDRange,
         &EnqueueWaitlistTest::enqueueMapBuffer,
         &EnqueueWaitlistTest::enqueueUnMapBuffer,
         &EnqueueWaitlistTest::enqueueMapImage};
 
-ExecuteEnqueue TwoEnqueueMap[] =
+ExecuteEnqueue twoEnqueueMap[] =
     {
         &EnqueueWaitlistTest::twoEnqueueMapBuffer,
         &EnqueueWaitlistTest::twoEnqueueMapImage};
@@ -236,10 +236,10 @@ ExecuteEnqueue TwoEnqueueMap[] =
 INSTANTIATE_TEST_CASE_P(
     UnblockedEvent,
     EnqueueWaitlistTest,
-    ::testing::ValuesIn(Enqueues));
+    ::testing::ValuesIn(enqueues));
 
 INSTANTIATE_TEST_CASE_P(
     TwoEnqueueMap,
     EnqueueWaitlistTestTwoMapEnqueues,
-    ::testing::ValuesIn(TwoEnqueueMap));
+    ::testing::ValuesIn(twoEnqueueMap));
 } // namespace ULT

opencl/test/unit_test/command_stream/command_stream_receiver_hw_1_tests.cpp

@@ -1339,7 +1339,7 @@ struct BcsTestParam {
     size_t dstSlicePitch;
     size_t srcRowPitch;
     size_t srcSlicePitch;
-} BlitterProperties[] = {
+} blitterProperties[] = {
     {{(2 * BlitterConstants::maxBlitWidth * BlitterConstants::maxBlitHeight) + 17, 1, 1},
      {0, 1, 1},
      {BlitterConstants::maxBlitWidth, 1, 1},
@@ -1695,7 +1695,7 @@ HWTEST_P(BcsDetaliedTestsWithParams, givenBltSizeWithLeftoverWhenDispatchedThenP
 INSTANTIATE_TEST_CASE_P(BcsDetaliedTest,
                         BcsDetaliedTestsWithParams,
                         ::testing::Combine(
-                            ::testing::ValuesIn(BlitterProperties),
+                            ::testing::ValuesIn(blitterProperties),
                             ::testing::Values(BlitterConstants::BlitDirection::hostPtrToBuffer, BlitterConstants::BlitDirection::bufferToHostPtr)));
 
 HWCMDTEST_F(IGFX_GEN8_CORE, UltCommandStreamReceiverTest, WhenProgrammingActivePartitionsThenExpectNoAction) {

opencl/test/unit_test/context/get_supported_image_formats_tests.cpp

@@ -442,12 +442,12 @@ TEST_P(NV12ExtensionSupportedImageFormatsTest, WhenRetrievingLessImageFormatsTha
     delete[] imageFormatList;
 }
 
-cl_mem_flags GetSupportedImageFormatsFlags[] = {
+cl_mem_flags getSupportedImageFormatsFlags[] = {
     CL_MEM_READ_WRITE,
     CL_MEM_WRITE_ONLY,
     CL_MEM_READ_ONLY};
 
-cl_mem_object_type GetSupportedImageFormats[] = {
+cl_mem_object_type getSupportedImageFormats[] = {
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE1D_BUFFER,
     CL_MEM_OBJECT_IMAGE1D_ARRAY,
@@ -459,25 +459,25 @@ INSTANTIATE_TEST_CASE_P(
     Context,
     GetSupportedImageFormatsTest,
     ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedImageFormatsFlags),
+        ::testing::ValuesIn(getSupportedImageFormatsFlags),
-        ::testing::ValuesIn(GetSupportedImageFormats)));
+        ::testing::ValuesIn(getSupportedImageFormats)));
 
 INSTANTIATE_TEST_CASE_P(
     Context,
     PackedYuvExtensionSupportedImageFormatsTest,
     ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedImageFormatsFlags),
+        ::testing::ValuesIn(getSupportedImageFormatsFlags),
-        ::testing::ValuesIn(GetSupportedImageFormats)));
+        ::testing::ValuesIn(getSupportedImageFormats)));
 
-cl_mem_flags NV12ExtensionSupportedImageFormatsFlags[] = {
+cl_mem_flags nv12ExtensionSupportedImageFormatsFlags[] = {
     CL_MEM_NO_ACCESS_INTEL,
     CL_MEM_READ_ONLY};
 
-cl_mem_flags NV12ExtensionUnsupportedImageFormatsFlags[] = {
+cl_mem_flags nv12ExtensionUnsupportedImageFormatsFlags[] = {
     CL_MEM_READ_WRITE,
     CL_MEM_WRITE_ONLY};
 
-cl_mem_object_type NV12ExtensionSupportedImageFormats[] = {
+cl_mem_object_type nv12ExtensionSupportedImageFormats[] = {
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE2D};
 
@@ -485,12 +485,12 @@ INSTANTIATE_TEST_CASE_P(
     Context,
     NV12ExtensionSupportedImageFormatsTest,
     ::testing::Combine(
-        ::testing::ValuesIn(NV12ExtensionSupportedImageFormatsFlags),
+        ::testing::ValuesIn(nv12ExtensionSupportedImageFormatsFlags),
-        ::testing::ValuesIn(NV12ExtensionSupportedImageFormats)));
+        ::testing::ValuesIn(nv12ExtensionSupportedImageFormats)));
 
 INSTANTIATE_TEST_CASE_P(
     Context,
     NV12ExtensionUnsupportedImageFormatsTest,
     ::testing::Combine(
-        ::testing::ValuesIn(NV12ExtensionUnsupportedImageFormatsFlags),
+        ::testing::ValuesIn(nv12ExtensionUnsupportedImageFormatsFlags),
-        ::testing::ValuesIn(NV12ExtensionSupportedImageFormats)));
+        ::testing::ValuesIn(nv12ExtensionSupportedImageFormats)));

opencl/test/unit_test/gtpin/gtpin_tests.cpp

@@ -66,12 +66,12 @@ extern GTPinGfxCoreHelperCreateFunctionType gtpinGfxCoreHelperFactory[IGFX_MAX_C
 
 namespace ULT {
 
-int ContextCreateCallbackCount = 0;
+int contextCreateCallbackCount = 0;
-int ContextDestroyCallbackCount = 0;
+int contextDestroyCallbackCount = 0;
-int KernelCreateCallbackCount = 0;
+int kernelCreateCallbackCount = 0;
-int KernelSubmitCallbackCount = 0;
+int kernelSubmitCallbackCount = 0;
-int CommandBufferCreateCallbackCount = 0;
+int commandBufferCreateCallbackCount = 0;
-int CommandBufferCompleteCallbackCount = 0;
+int commandBufferCompleteCallbackCount = 0;
 uint32_t kernelOffset = 0;
 bool returnNullResource = false;
 
@@ -84,7 +84,7 @@ void onContextCreate(context_handle_t context, platform_info_t *platformInfo, ig
     ULT::platformInfo.gen_version = platformInfo->gen_version;
     currContext = context;
     kernelResources.clear();
-    ContextCreateCallbackCount++;
+    contextCreateCallbackCount++;
     *igcInit = reinterpret_cast<igc_init_t *>(0x1234);
 }
 
@@ -92,14 +92,14 @@ void onContextDestroy(context_handle_t context) {
     currContext = nullptr;
     EXPECT_EQ(0u, kernelResources.size());
     kernelResources.clear();
-    ContextDestroyCallbackCount++;
+    contextDestroyCallbackCount++;
 }
 
 void onKernelCreate(context_handle_t context, const instrument_params_in_t *paramsIn, instrument_params_out_t *paramsOut) {
     paramsOut->inst_kernel_binary = const_cast<uint8_t *>(paramsIn->orig_kernel_binary);
     paramsOut->inst_kernel_size = paramsIn->orig_kernel_size;
     paramsOut->kernel_id = paramsIn->igc_hash_id;
-    KernelCreateCallbackCount++;
+    kernelCreateCallbackCount++;
 }
 
 void onKernelSubmit(command_buffer_handle_t cb, uint64_t kernelId, uint32_t *entryOffset, resource_handle_t *resource) {
@@ -119,11 +119,11 @@ void onKernelSubmit(command_buffer_handle_t cb, uint64_t kernelId, uint32_t *ent
     *resource = currResource;
     kernelResources.push_back(currResource);
 
-    KernelSubmitCallbackCount++;
+    kernelSubmitCallbackCount++;
 }
 
 void onCommandBufferCreate(context_handle_t context, command_buffer_handle_t cb) {
-    CommandBufferCreateCallbackCount++;
+    commandBufferCreateCallbackCount++;
 }
 
 void onCommandBufferComplete(command_buffer_handle_t cb) {
@@ -137,7 +137,7 @@ void onCommandBufferComplete(command_buffer_handle_t cb) {
     EXPECT_EQ(GTPIN_DI_SUCCESS, st);
     kernelResources.pop_front();
 
-    CommandBufferCompleteCallbackCount++;
+    commandBufferCompleteCallbackCount++;
 }
 
 class MockMemoryManagerWithFailures : public OsAgnosticMemoryManager {
@@ -593,17 +593,17 @@ TEST_F(GTPinTests, givenValidArgumentsForBufferUnMapWhenCallSequenceIsCorrectThe
 }
 
 TEST_F(GTPinTests, givenUninitializedGTPinInterfaceThenGTPinContextCallbackIsNotCalled) {
-    int prevCount = ContextCreateCallbackCount;
+    int prevCount = contextCreateCallbackCount;
     cl_device_id device = (cl_device_id)pDevice;
     auto context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, &retVal);
     EXPECT_EQ(CL_SUCCESS, retVal);
     EXPECT_NE(nullptr, context);
-    EXPECT_EQ(ContextCreateCallbackCount, prevCount);
+    EXPECT_EQ(contextCreateCallbackCount, prevCount);
 
-    prevCount = ContextDestroyCallbackCount;
+    prevCount = contextDestroyCallbackCount;
     retVal = clReleaseContext(context);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(ContextDestroyCallbackCount, prevCount);
+    EXPECT_EQ(contextDestroyCallbackCount, prevCount);
 }
 
 TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenContextCreationArgumentsAreInvalidThenGTPinContextCallbackIsNotCalled) {
@@ -616,18 +616,18 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenContextCreationArgumentsAre
     retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, nullptr);
     EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
 
-    int prevCount = ContextCreateCallbackCount;
+    int prevCount = contextCreateCallbackCount;
     cl_device_id device = (cl_device_id)pDevice;
     cl_context_properties invalidProperties[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties) nullptr, 0};
     auto context = clCreateContext(invalidProperties, 1, &device, nullptr, nullptr, &retVal);
     EXPECT_EQ(CL_INVALID_PLATFORM, retVal);
     EXPECT_EQ(nullptr, context);
-    EXPECT_EQ(ContextCreateCallbackCount, prevCount);
+    EXPECT_EQ(contextCreateCallbackCount, prevCount);
 
     context = clCreateContextFromType(invalidProperties, CL_DEVICE_TYPE_GPU, nullptr, nullptr, &retVal);
     EXPECT_EQ(CL_INVALID_PLATFORM, retVal);
     EXPECT_EQ(nullptr, context);
-    EXPECT_EQ(ContextCreateCallbackCount, prevCount);
+    EXPECT_EQ(contextCreateCallbackCount, prevCount);
 }
 
 TEST_F(GTPinTests, givenInitializedGTPinInterfaceThenGTPinContextCallbackIsCalled) {
@@ -640,28 +640,28 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceThenGTPinContextCallbackIsCalle
     retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, nullptr);
     EXPECT_EQ(GTPIN_DI_SUCCESS, retFromGtPin);
 
-    int prevCount = ContextCreateCallbackCount;
+    int prevCount = contextCreateCallbackCount;
     cl_device_id device = (cl_device_id)pDevice;
     auto context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, &retVal);
     EXPECT_EQ(CL_SUCCESS, retVal);
     EXPECT_NE(nullptr, context);
-    EXPECT_EQ(ContextCreateCallbackCount, prevCount + 1);
+    EXPECT_EQ(contextCreateCallbackCount, prevCount + 1);
 
-    prevCount = ContextDestroyCallbackCount;
+    prevCount = contextDestroyCallbackCount;
     retVal = clReleaseContext(context);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(ContextDestroyCallbackCount, prevCount + 1);
+    EXPECT_EQ(contextDestroyCallbackCount, prevCount + 1);
 
-    prevCount = ContextCreateCallbackCount;
+    prevCount = contextCreateCallbackCount;
     context = clCreateContextFromType(nullptr, CL_DEVICE_TYPE_GPU, nullptr, nullptr, &retVal);
     EXPECT_EQ(CL_SUCCESS, retVal);
     EXPECT_NE(nullptr, context);
-    EXPECT_EQ(ContextCreateCallbackCount, prevCount + 1);
+    EXPECT_EQ(contextCreateCallbackCount, prevCount + 1);
 
-    prevCount = ContextDestroyCallbackCount;
+    prevCount = contextDestroyCallbackCount;
     retVal = clReleaseContext(context);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(ContextDestroyCallbackCount, prevCount + 1);
+    EXPECT_EQ(contextDestroyCallbackCount, prevCount + 1);
 }
 
 TEST_F(GTPinTests, givenUninitializedGTPinInterfaceThenGTPinKernelCreateCallbackIsNotCalled) {
@@ -696,11 +696,11 @@ TEST_F(GTPinTests, givenUninitializedGTPinInterfaceThenGTPinKernelCreateCallback
         nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount = KernelCreateCallbackCount;
+    int prevCount = kernelCreateCallbackCount;
     kernel = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount, kernelCreateCallbackCount);
 
     // Cleanup
     retVal = clReleaseKernel(kernel);
@@ -793,11 +793,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsExecutedThenGTPinCa
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     // Create and submit first instance of "CopyBuffer" kernel
-    int prevCount11 = KernelCreateCallbackCount;
+    int prevCount11 = kernelCreateCallbackCount;
     kernel1 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel1);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount11 + 1, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount11 + 1, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel1 = static_cast<MultiDeviceKernel *>(kernel1);
     Kernel *pKernel1 = pMultiDeviceKernel1->getKernel(rootDeviceIndex);
@@ -814,25 +814,25 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsExecutedThenGTPinCa
     retVal = clSetKernelArg(pMultiDeviceKernel1, 1, sizeof(cl_mem), &buff11);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount12 = KernelSubmitCallbackCount;
+    int prevCount12 = kernelSubmitCallbackCount;
-    int prevCount13 = CommandBufferCreateCallbackCount;
+    int prevCount13 = commandBufferCreateCallbackCount;
-    int prevCount14 = CommandBufferCompleteCallbackCount;
+    int prevCount14 = commandBufferCompleteCallbackCount;
     cl_uint workDim = 1;
     size_t globalWorkOffset[3] = {0, 0, 0};
     size_t globalWorkSize[3] = {n, 1, 1};
     size_t localWorkSize[3] = {1, 1, 1};
     retVal = clEnqueueNDRangeKernel(cmdQ, pMultiDeviceKernel1, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount12 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount13 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount13 + 1, commandBufferCreateCallbackCount);
 
     // Create and submit second instance of "CopyBuffer" kernel
-    int prevCount21 = KernelCreateCallbackCount;
+    int prevCount21 = kernelCreateCallbackCount;
     kernel2 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel2);
     EXPECT_EQ(CL_SUCCESS, retVal);
     // Verify that GT-Pin Kernel Create callback is not called multiple times for the same kernel
-    EXPECT_EQ(prevCount21, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount21, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel2 = static_cast<MultiDeviceKernel *>(kernel2);
     Kernel *pKernel2 = pMultiDeviceKernel2->getKernel(rootDeviceIndex);
@@ -848,18 +848,18 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsExecutedThenGTPinCa
     retVal = clSetKernelArg(pMultiDeviceKernel2, 1, sizeof(cl_mem), &buff21);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount22 = KernelSubmitCallbackCount;
+    int prevCount22 = kernelSubmitCallbackCount;
-    int prevCount23 = CommandBufferCreateCallbackCount;
+    int prevCount23 = commandBufferCreateCallbackCount;
-    int prevCount24 = CommandBufferCompleteCallbackCount;
+    int prevCount24 = commandBufferCompleteCallbackCount;
     retVal = clEnqueueNDRangeKernel(cmdQ, pMultiDeviceKernel2, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount22 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount23 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
 
     retVal = clFinish(cmdQ);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount14 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount14 + 2, commandBufferCompleteCallbackCount);
-    EXPECT_EQ(prevCount24 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount24 + 2, commandBufferCompleteCallbackCount);
 
     // Cleanup
     retVal = clReleaseKernel(kernel1);
@@ -949,11 +949,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelINTELIsExecutedThenGT
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     // Create and submit first instance of "CopyBuffer" kernel
-    int prevCount11 = KernelCreateCallbackCount;
+    int prevCount11 = kernelCreateCallbackCount;
     kernel1 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel1);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount11 + 1, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount11 + 1, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel1 = static_cast<MultiDeviceKernel *>(kernel1);
     Kernel *pKernel1 = pMultiDeviceKernel1->getKernel(rootDeviceIndex);
@@ -974,23 +974,23 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelINTELIsExecutedThenGT
     retVal = clSetKernelArg(pMultiDeviceKernel1, 1, sizeof(cl_mem), &buff11);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount12 = KernelSubmitCallbackCount;
+    int prevCount12 = kernelSubmitCallbackCount;
-    int prevCount13 = CommandBufferCreateCallbackCount;
+    int prevCount13 = commandBufferCreateCallbackCount;
-    int prevCount14 = CommandBufferCompleteCallbackCount;
+    int prevCount14 = commandBufferCompleteCallbackCount;
     size_t globalWorkOffset[3] = {0, 0, 0};
     size_t workgroupCount[3] = {n, 1, 1};
     retVal = clEnqueueNDCountKernelINTEL(cmdQ, pMultiDeviceKernel1, workDim, globalWorkOffset, workgroupCount, localWorkSize, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount12 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount13 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount13 + 1, commandBufferCreateCallbackCount);
 
     // Create and submit second instance of "CopyBuffer" kernel
-    int prevCount21 = KernelCreateCallbackCount;
+    int prevCount21 = kernelCreateCallbackCount;
     kernel2 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel2);
     EXPECT_EQ(CL_SUCCESS, retVal);
     // Verify that GT-Pin Kernel Create callback is not called multiple times for the same kernel
-    EXPECT_EQ(prevCount21, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount21, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel2 = static_cast<MultiDeviceKernel *>(kernel2);
     Kernel *pKernel2 = pMultiDeviceKernel2->getKernel(rootDeviceIndex);
@@ -1006,18 +1006,18 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelINTELIsExecutedThenGT
     retVal = clSetKernelArg(pMultiDeviceKernel2, 1, sizeof(cl_mem), &buff21);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount22 = KernelSubmitCallbackCount;
+    int prevCount22 = kernelSubmitCallbackCount;
-    int prevCount23 = CommandBufferCreateCallbackCount;
+    int prevCount23 = commandBufferCreateCallbackCount;
-    int prevCount24 = CommandBufferCompleteCallbackCount;
+    int prevCount24 = commandBufferCompleteCallbackCount;
     retVal = clEnqueueNDCountKernelINTEL(cmdQ, pMultiDeviceKernel2, workDim, globalWorkOffset, workgroupCount, localWorkSize, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount22 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount23 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
 
     retVal = clFinish(cmdQ);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount14 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount14 + 2, commandBufferCompleteCallbackCount);
-    EXPECT_EQ(prevCount24 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount24 + 2, commandBufferCompleteCallbackCount);
 
     // Cleanup
     retVal = clReleaseKernel(kernel1);
@@ -1107,11 +1107,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenTheSameKerneIsExecutedTwice
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     // Kernel "CopyBuffer" - called for the first time
-    int prevCount11 = KernelCreateCallbackCount;
+    int prevCount11 = kernelCreateCallbackCount;
     kernel1 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel1);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount11 + 1, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount11 + 1, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel1 = static_cast<MultiDeviceKernel *>(kernel1);
     Kernel *pKernel1 = pMultiDeviceKernel1->getKernel(rootDeviceIndex);
@@ -1131,26 +1131,26 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenTheSameKerneIsExecutedTwice
     cl_event userEvent = clCreateUserEvent(context, &retVal);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount12 = KernelSubmitCallbackCount;
+    int prevCount12 = kernelSubmitCallbackCount;
-    int prevCount13 = CommandBufferCreateCallbackCount;
+    int prevCount13 = commandBufferCreateCallbackCount;
-    int prevCount14 = CommandBufferCompleteCallbackCount;
+    int prevCount14 = commandBufferCompleteCallbackCount;
     cl_uint workDim = 1;
     size_t globalWorkOffset[3] = {0, 0, 0};
     size_t globalWorkSize[3] = {n, 1, 1};
     size_t localWorkSize[3] = {1, 1, 1};
     retVal = clEnqueueNDRangeKernel(cmdQ, pMultiDeviceKernel1, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 1, &userEvent, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount12 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount13 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount13 + 1, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount14, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount14, commandBufferCompleteCallbackCount);
 
     // The same kernel "CopyBuffer" - called second time
-    int prevCount21 = KernelCreateCallbackCount;
+    int prevCount21 = kernelCreateCallbackCount;
     kernel2 = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     EXPECT_NE(nullptr, kernel2);
     EXPECT_EQ(CL_SUCCESS, retVal);
     // Verify that Kernel Create callback was not called now
-    EXPECT_EQ(prevCount21, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount21, kernelCreateCallbackCount);
 
     MultiDeviceKernel *pMultiDeviceKernel2 = static_cast<MultiDeviceKernel *>(kernel2);
     Kernel *pKernel2 = pMultiDeviceKernel2->getKernel(rootDeviceIndex);
@@ -1166,16 +1166,16 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenTheSameKerneIsExecutedTwice
     retVal = clSetKernelArg(pMultiDeviceKernel2, 1, sizeof(cl_mem), &buff21);
     EXPECT_EQ(CL_SUCCESS, retVal);
 
-    int prevCount22 = KernelSubmitCallbackCount;
+    int prevCount22 = kernelSubmitCallbackCount;
-    int prevCount23 = CommandBufferCreateCallbackCount;
+    int prevCount23 = commandBufferCreateCallbackCount;
-    int prevCount24 = CommandBufferCompleteCallbackCount;
+    int prevCount24 = commandBufferCompleteCallbackCount;
     EXPECT_EQ(prevCount14, prevCount24);
     retVal = clEnqueueNDRangeKernel(cmdQ, pMultiDeviceKernel2, workDim, globalWorkOffset, globalWorkSize, localWorkSize, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount22 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
-    EXPECT_EQ(prevCount23 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount14, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount14, commandBufferCompleteCallbackCount);
-    EXPECT_EQ(prevCount24, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount24, commandBufferCompleteCallbackCount);
     EXPECT_EQ(prevCount14, prevCount24);
 
     clSetUserEventStatus(userEvent, CL_COMPLETE);
@@ -1183,8 +1183,8 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenTheSameKerneIsExecutedTwice
     retVal = clFinish(cmdQ);
     EXPECT_EQ(CL_SUCCESS, retVal);
     // Verify that both kernel instances were completed
-    EXPECT_EQ(prevCount14 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount14 + 2, commandBufferCompleteCallbackCount);
-    EXPECT_EQ(prevCount24 + 2, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount24 + 2, commandBufferCompleteCallbackCount);
 
     // Cleanup
     retVal = clReleaseKernel(kernel1);
@@ -1404,11 +1404,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsCreatedThenAllKerne
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     // Create kernel
-    int prevCount1 = KernelCreateCallbackCount;
+    int prevCount1 = kernelCreateCallbackCount;
     kernel = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     ASSERT_NE(nullptr, kernel);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount1 + 1, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount1 + 1, kernelCreateCallbackCount);
 
     // Simulate that created kernel was sent for execution
     auto pMultiDeviceKernel = castToObject<MultiDeviceKernel>(kernel);
@@ -1417,11 +1417,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsCreatedThenAllKerne
     ASSERT_NE(nullptr, pKernel);
     EXPECT_EQ(0u, kernelExecQueue.size());
     EXPECT_EQ(0u, kernelResources.size());
-    int prevCount2 = CommandBufferCreateCallbackCount;
+    int prevCount2 = commandBufferCreateCallbackCount;
-    int prevCount3 = KernelSubmitCallbackCount;
+    int prevCount3 = kernelSubmitCallbackCount;
     gtpinNotifyKernelSubmit(kernel, pCmdQueue);
-    EXPECT_EQ(prevCount2 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount2 + 1, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount3 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount3 + 1, kernelSubmitCallbackCount);
     EXPECT_EQ(1u, kernelExecQueue.size());
     EXPECT_EQ(1u, kernelResources.size());
     EXPECT_EQ(pKernel, kernelExecQueue[0].pKernel);
@@ -1459,11 +1459,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsCreatedThenAllKerne
     ASSERT_NE(nullptr, pKernel2);
     EXPECT_EQ(1u, kernelExecQueue.size());
     EXPECT_EQ(1u, kernelResources.size());
-    int prevCount22 = CommandBufferCreateCallbackCount;
+    int prevCount22 = commandBufferCreateCallbackCount;
-    int prevCount23 = KernelSubmitCallbackCount;
+    int prevCount23 = kernelSubmitCallbackCount;
     gtpinNotifyKernelSubmit(kernel2, pCmdQueue);
-    EXPECT_EQ(prevCount22 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount22 + 1, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount23 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount23 + 1, kernelSubmitCallbackCount);
     EXPECT_EQ(2u, kernelExecQueue.size());
     EXPECT_EQ(2u, kernelResources.size());
     EXPECT_EQ(pKernel2, kernelExecQueue[1].pKernel);
@@ -1516,17 +1516,17 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelIsCreatedThenAllKerne
 
     // Verify that if previous task was completed then it does not affect our kernel
     TaskCountType taskCompleted = taskCount - 1;
-    int prevCount4 = CommandBufferCompleteCallbackCount;
+    int prevCount4 = commandBufferCompleteCallbackCount;
     gtpinNotifyTaskCompletion(taskCompleted);
     EXPECT_EQ(1u, kernelExecQueue.size());
     EXPECT_EQ(1u, kernelResources.size());
-    EXPECT_EQ(prevCount4, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount4, commandBufferCompleteCallbackCount);
 
     // Verify that if current task was completed then it is our kernel
     gtpinNotifyTaskCompletion(taskCompleted + 1);
     EXPECT_EQ(0u, kernelExecQueue.size());
     EXPECT_EQ(0u, kernelResources.size());
-    EXPECT_EQ(prevCount4 + 1, CommandBufferCompleteCallbackCount);
+    EXPECT_EQ(prevCount4 + 1, commandBufferCompleteCallbackCount);
 
     // Cleanup
     retVal = clReleaseKernel(kernel);
@@ -1605,11 +1605,11 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOneKernelIsSubmittedSeveral
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     // Create kernel
-    int prevCount1 = KernelCreateCallbackCount;
+    int prevCount1 = kernelCreateCallbackCount;
     kernel = clCreateKernel(pProgram, "CopyBuffer", &retVal);
     ASSERT_NE(nullptr, kernel);
     EXPECT_EQ(CL_SUCCESS, retVal);
-    EXPECT_EQ(prevCount1 + 1, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCount1 + 1, kernelCreateCallbackCount);
 
     // Simulate that created kernel was sent for execution two times in a row
     auto pMultiDeviceKernel = castToObject<MultiDeviceKernel>(kernel);
@@ -1618,12 +1618,12 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOneKernelIsSubmittedSeveral
     ASSERT_NE(nullptr, pKernel);
     EXPECT_EQ(0u, kernelExecQueue.size());
     EXPECT_EQ(0u, kernelResources.size());
-    int prevCount2 = CommandBufferCreateCallbackCount;
+    int prevCount2 = commandBufferCreateCallbackCount;
-    int prevCount3 = KernelSubmitCallbackCount;
+    int prevCount3 = kernelSubmitCallbackCount;
     // First kernel submission
     gtpinNotifyKernelSubmit(kernel, pCmdQueue);
-    EXPECT_EQ(prevCount2 + 1, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount2 + 1, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount3 + 1, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount3 + 1, kernelSubmitCallbackCount);
     EXPECT_EQ(1u, kernelExecQueue.size());
     EXPECT_EQ(1u, kernelResources.size());
     EXPECT_EQ(pKernel, kernelExecQueue[0].pKernel);
@@ -1633,8 +1633,8 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOneKernelIsSubmittedSeveral
     EXPECT_FALSE(kernelExecQueue[0].isResourceResident);
     // Second kernel submission
     gtpinNotifyKernelSubmit(kernel, pCmdQueue);
-    EXPECT_EQ(prevCount2 + 2, CommandBufferCreateCallbackCount);
+    EXPECT_EQ(prevCount2 + 2, commandBufferCreateCallbackCount);
-    EXPECT_EQ(prevCount3 + 2, KernelSubmitCallbackCount);
+    EXPECT_EQ(prevCount3 + 2, kernelSubmitCallbackCount);
     EXPECT_EQ(2u, kernelExecQueue.size());
     EXPECT_EQ(2u, kernelResources.size());
     EXPECT_EQ(pKernel, kernelExecQueue[0].pKernel);
@@ -2008,9 +2008,9 @@ TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenOnKernelCreateIsCalledWithN
     gtpinCallbacks.onCommandBufferCreate = onCommandBufferCreate;
     gtpinCallbacks.onCommandBufferComplete = onCommandBufferComplete;
     retFromGtPin = GTPin_Init(&gtpinCallbacks, &driverServices, nullptr);
-    auto prevCreateCount = KernelCreateCallbackCount;
+    auto prevCreateCount = kernelCreateCallbackCount;
     gtpinNotifyKernelCreate(nullptr);
-    EXPECT_EQ(prevCreateCount, KernelCreateCallbackCount);
+    EXPECT_EQ(prevCreateCount, kernelCreateCallbackCount);
 }
 
 TEST_F(GTPinTests, givenInitializedGTPinInterfaceWhenKernelDoesNotHaveDebugDataThenPassNullPtrToOnKernelCreate) {

opencl/test/unit_test/kernel/kernel_tests.cpp

@@ -3054,14 +3054,14 @@ TEST_P(ThreadArbitrationPolicyKernelTest, givenThreadArbitrationPolicyAndIFPNotR
     EXPECT_EQ(GetParam(), mockKernel.getDescriptor().kernelAttributes.threadArbitrationPolicy);
 }
 
-static ThreadArbitrationPolicy ThreadArbitrationPolicies[] = {
+static ThreadArbitrationPolicy threadArbitrationPolicies[] = {
     ThreadArbitrationPolicy::AgeBased,
     ThreadArbitrationPolicy::RoundRobin,
     ThreadArbitrationPolicy::RoundRobinAfterDependency};
 
 INSTANTIATE_TEST_CASE_P(ThreadArbitrationPolicyKernelInitializationTests,
                         ThreadArbitrationPolicyKernelTest,
-                        testing::ValuesIn(ThreadArbitrationPolicies));
+                        testing::ValuesIn(threadArbitrationPolicies));
 
 TEST(KernelTest, givenKernelWhenSettingAdditionalKernelExecInfoThenCorrectValueIsSet) {
     UltClDeviceFactory deviceFactory{1, 0};

opencl/test/unit_test/mem_obj/buffer_tests.cpp

@@ -982,7 +982,7 @@ TEST_P(NoHostPtr, WhenGettingAllocationTypeThenCorrectBufferTypeIsReturned) {
 
 // Parameterized test that tests buffer creation with all flags
 // that should be valid with a nullptr host ptr
-cl_mem_flags NoHostPtrFlags[] = {
+cl_mem_flags noHostPtrFlags[] = {
     CL_MEM_READ_WRITE,
     CL_MEM_WRITE_ONLY,
     CL_MEM_READ_ONLY,
@@ -993,7 +993,7 @@ cl_mem_flags NoHostPtrFlags[] = {
 INSTANTIATE_TEST_CASE_P(
     BufferTest_Create,
     NoHostPtr,
-    testing::ValuesIn(NoHostPtrFlags));
+    testing::ValuesIn(noHostPtrFlags));
 
 struct ValidHostPtr
     : public BufferTest,
@@ -1209,7 +1209,7 @@ TEST_P(ValidHostPtr, WhenValidateInputAndCreateBufferThenCorrectBufferIsSet) {
 
 // Parameterized test that tests buffer creation with all flags that should be
 // valid with a valid host ptr
-cl_mem_flags ValidHostPtrFlags[] = {
+cl_mem_flags validHostPtrFlags[] = {
     0 | CL_MEM_USE_HOST_PTR,
     CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
     CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR,
@@ -1228,7 +1228,7 @@ cl_mem_flags ValidHostPtrFlags[] = {
 INSTANTIATE_TEST_CASE_P(
     BufferTest_Create,
     ValidHostPtr,
-    testing::ValuesIn(ValidHostPtrFlags));
+    testing::ValuesIn(validHostPtrFlags));
 
 class BufferCalculateHostPtrSize : public testing::TestWithParam<std::tuple<size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t>> {
   public:

opencl/test/unit_test/mem_obj/image1d_tests.cpp

@@ -133,7 +133,7 @@ HWTEST_P(CreateImage1DType, GivenValidTypeWhenCreatingImageThenImageParamsAreCor
     delete image;
 }
 
-static cl_mem_object_type Image1DTypes[] = {
+static cl_mem_object_type image1DTypes[] = {
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE1D_BUFFER,
     CL_MEM_OBJECT_IMAGE1D_ARRAY};
@@ -141,4 +141,4 @@ static cl_mem_object_type Image1DTypes[] = {
 INSTANTIATE_TEST_CASE_P(
     CreateImage1DTestCreate,
     CreateImage1DType,
-    testing::ValuesIn(Image1DTypes));
+    testing::ValuesIn(image1DTypes));

opencl/test/unit_test/mem_obj/image_array_size_tests.cpp

@@ -100,14 +100,14 @@ HWTEST_P(CreateImageArraySize, GivenArrayTypeWhenCreatingImageThenImageCreatedWi
     delete image;
 }
 
-static cl_mem_object_type ArrayImageTypes[] = {
+static cl_mem_object_type arrayImageTypes[] = {
     CL_MEM_OBJECT_IMAGE1D_ARRAY,
     CL_MEM_OBJECT_IMAGE2D_ARRAY};
 
 INSTANTIATE_TEST_CASE_P(
     ImageArraySizeTestCreate,
     CreateImageArraySize,
-    testing::ValuesIn(ArrayImageTypes));
+    testing::ValuesIn(arrayImageTypes));
 
 typedef ImageArraySizeTest CreateImageNonArraySize;
 
@@ -139,7 +139,7 @@ HWTEST_P(CreateImageNonArraySize, GivenNonArrayTypeWhenCreatingImageThenImageCre
     delete image;
 }
 
-static cl_mem_object_type NonArrayImageTypes[] = {
+static cl_mem_object_type nonArrayImageTypes[] = {
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE1D_BUFFER,
     CL_MEM_OBJECT_IMAGE2D,
@@ -148,7 +148,7 @@ static cl_mem_object_type NonArrayImageTypes[] = {
 INSTANTIATE_TEST_CASE_P(
     ImageArraySizeTest_Create,
     CreateImageNonArraySize,
-    testing::ValuesIn(NonArrayImageTypes));
+    testing::ValuesIn(nonArrayImageTypes));
 
 typedef ImageArraySizeTest CreateImageSize;
 
@@ -232,7 +232,7 @@ TEST_P(CheckImageType, GivenImageTypeWhenImageTypeIsCheckedThenProperValueIsRetu
     }
 }
 
-static cl_mem_object_type AllImageTypes[] = {
+static cl_mem_object_type allImageTypes[] = {
     0, // negative scenario
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE1D_BUFFER,
@@ -244,9 +244,9 @@ static cl_mem_object_type AllImageTypes[] = {
 INSTANTIATE_TEST_CASE_P(
     ImageArraySizeTest_Create,
     CreateImageSize,
-    testing::ValuesIn(AllImageTypes));
+    testing::ValuesIn(allImageTypes));
 
-static cl_mem_object_type AllImageTypesWithBadOne[] = {
+static cl_mem_object_type allImageTypesWithBadOne[] = {
     0, // negative scenario
     CL_MEM_OBJECT_BUFFER,
     CL_MEM_OBJECT_IMAGE1D,
@@ -259,4 +259,4 @@ static cl_mem_object_type AllImageTypesWithBadOne[] = {
 INSTANTIATE_TEST_CASE_P(
     ImageArraySizeTest_Create,
     CreateImageOffset,
-    testing::ValuesIn(AllImageTypesWithBadOne));
+    testing::ValuesIn(allImageTypesWithBadOne));

opencl/test/unit_test/mem_obj/image_redescribe_tests.cpp

@@ -215,7 +215,7 @@ TEST_P(ImageRedescribeTest, givenImageWithMaxSizesWhenItIsRedescribedThenNewImag
               imageNew->getImageDesc().image_height);
 }
 
-static uint32_t ImageTypes[] = {
+static uint32_t imageTypes[] = {
     CL_MEM_OBJECT_IMAGE1D,
     CL_MEM_OBJECT_IMAGE2D,
     CL_MEM_OBJECT_IMAGE1D_ARRAY,
@@ -227,7 +227,7 @@ INSTANTIATE_TEST_CASE_P(
     ImageRedescribeTest,
     testing::Combine(
         ::testing::Range(readWriteSurfaceFormatsStart, SurfaceFormats::readWrite().size()),
-        ::testing::ValuesIn(ImageTypes)));
+        ::testing::ValuesIn(imageTypes)));
 
 TEST(ImageRedescribeTestSimple, givenImageWhenItIsRedescribedThenCreateFunctionIsSameAsInOriginalImage) {
     MockContext context;

opencl/test/unit_test/mem_obj/image_tests.cpp

@@ -645,7 +645,7 @@ TEST_P(CreateImageNoHostPtr, whenImageIsCreatedThenItHasProperAccessAndCacheProp
 
 // Parameterized test that tests image creation with all flags that should be
 // valid with a nullptr host ptr
-static cl_mem_flags NoHostPtrFlags[] = {
+static cl_mem_flags noHostPtrFlags[] = {
     CL_MEM_READ_WRITE,
     CL_MEM_WRITE_ONLY,
     CL_MEM_READ_ONLY,
@@ -656,7 +656,7 @@ static cl_mem_flags NoHostPtrFlags[] = {
 INSTANTIATE_TEST_CASE_P(
     CreateImageTest_Create,
     CreateImageNoHostPtr,
-    testing::ValuesIn(NoHostPtrFlags));
+    testing::ValuesIn(noHostPtrFlags));
 
 struct CreateImageHostPtr
     : public CreateImageTest,
@@ -1068,7 +1068,7 @@ TEST_F(ImageTransfer, GivenNonZeroCopyNonZeroRowPitchWithExtraBytes1DArrayImageW
 
 // Parameterized test that tests image creation with all flags that should be
 // valid with a valid host ptr
-static cl_mem_flags ValidHostPtrFlags[] = {
+static cl_mem_flags validHostPtrFlags[] = {
     0 | CL_MEM_USE_HOST_PTR,
     CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
     CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR,
@@ -1087,7 +1087,7 @@ static cl_mem_flags ValidHostPtrFlags[] = {
 INSTANTIATE_TEST_CASE_P(
     CreateImageTest_Create,
     CreateImageHostPtr,
-    testing::ValuesIn(ValidHostPtrFlags));
+    testing::ValuesIn(validHostPtrFlags));
 
 TEST(ImageGetSurfaceFormatInfoTest, givenNullptrFormatWhenGetSurfaceFormatInfoIsCalledThenReturnsNullptr) {
     MockContext context;

opencl/test/unit_test/mem_obj/image_tiled_tests.cpp

@@ -166,13 +166,13 @@ TEST_P(CreateNonTiledImageTest, GivenSharedNonTiledImageWhenCheckingIsTiledThenF
 }
 
 // Parameterized test that tests image creation with tiled types
-static uint32_t TiledImageTypes[] = {
+static uint32_t tiledImageTypes[] = {
     CL_MEM_OBJECT_IMAGE2D,
     CL_MEM_OBJECT_IMAGE2D_ARRAY,
     CL_MEM_OBJECT_IMAGE3D};
 
-static uint32_t NonTiledImageTypes[] = {
+static uint32_t nonTiledImageTypes[] = {
     CL_MEM_OBJECT_IMAGE1D};
 
-INSTANTIATE_TEST_CASE_P(CreateTiledImageTest, CreateTiledImageTest, testing::ValuesIn(TiledImageTypes));
+INSTANTIATE_TEST_CASE_P(CreateTiledImageTest, CreateTiledImageTest, testing::ValuesIn(tiledImageTypes));
-INSTANTIATE_TEST_CASE_P(CreateNonTiledImageTest, CreateNonTiledImageTest, testing::ValuesIn(NonTiledImageTypes));
+INSTANTIATE_TEST_CASE_P(CreateNonTiledImageTest, CreateNonTiledImageTest, testing::ValuesIn(nonTiledImageTypes));