intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 16:24:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: correct variable naming

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-12-04 09:18:59 +00:00
committed by Compute-Runtime-Automation
parent 552c129c0b
commit 8884e94a38
14 changed files with 170 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
opencl/test/unit_test/aub_tests/command_queue/enqueue_kernel_aub_tests.cpp
View File

@@ -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(TestParamTable)));
::testing::ValuesIn(testSimdTable),
::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(TestParamTable)));
::testing::ValuesIn(testSimdTable),
::testing::ValuesIn(testParamTable)));
} // namespace ULT
struct AUBSimpleArgNonUniformFixture : public KernelAUBFixture<SimpleArgNonUniformKernelFixture> {

10
opencl/test/unit_test/aub_tests/command_stream/aub_walker_partition_tests_xehp_and_later.cpp
View File

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

16
opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
View File

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

10
opencl/test/unit_test/command_queue/enqueue_waitlist_tests.cpp
View File

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

4
opencl/test/unit_test/command_stream/command_stream_receiver_hw_1_tests.cpp
View File

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

26
opencl/test/unit_test/context/get_supported_image_formats_tests.cpp
View File

@@ -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(GetSupportedImageFormats)));
::testing::ValuesIn(getSupportedImageFormatsFlags),
::testing::ValuesIn(getSupportedImageFormats)));
INSTANTIATE_TEST_CASE_P(
Context,
PackedYuvExtensionSupportedImageFormatsTest,
::testing::Combine(
::testing::ValuesIn(GetSupportedImageFormatsFlags),
::testing::ValuesIn(GetSupportedImageFormats)));
::testing::ValuesIn(getSupportedImageFormatsFlags),
::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(NV12ExtensionSupportedImageFormats)));
::testing::ValuesIn(nv12ExtensionSupportedImageFormatsFlags),
::testing::ValuesIn(nv12ExtensionSupportedImageFormats)));
INSTANTIATE_TEST_CASE_P(
Context,
NV12ExtensionUnsupportedImageFormatsTest,
::testing::Combine(
::testing::ValuesIn(NV12ExtensionUnsupportedImageFormatsFlags),
::testing::ValuesIn(NV12ExtensionSupportedImageFormats)));
::testing::ValuesIn(nv12ExtensionUnsupportedImageFormatsFlags),
::testing::ValuesIn(nv12ExtensionSupportedImageFormats)));

206
opencl/test/unit_test/gtpin/gtpin_tests.cpp
View File

@@ -66,12 +66,12 @@ extern GTPinGfxCoreHelperCreateFunctionType gtpinGfxCoreHelperFactory[IGFX_MAX_C
namespace ULT {
int ContextCreateCallbackCount = 0;
int ContextDestroyCallbackCount = 0;
int KernelCreateCallbackCount = 0;
int KernelSubmitCallbackCount = 0;
int CommandBufferCreateCallbackCount = 0;
int CommandBufferCompleteCallbackCount = 0;
int contextCreateCallbackCount = 0;
int contextDestroyCallbackCount = 0;
int kernelCreateCallbackCount = 0;
int kernelSubmitCallbackCount = 0;
int commandBufferCreateCallbackCount = 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 prevCount13 = CommandBufferCreateCallbackCount;
int prevCount14 = CommandBufferCompleteCallbackCount;
int prevCount12 = kernelSubmitCallbackCount;
int prevCount13 = commandBufferCreateCallbackCount;
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(prevCount13 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
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 prevCount23 = CommandBufferCreateCallbackCount;
int prevCount24 = CommandBufferCompleteCallbackCount;
int prevCount22 = kernelSubmitCallbackCount;
int prevCount23 = commandBufferCreateCallbackCount;
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(prevCount23 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
retVal = clFinish(cmdQ);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(prevCount14 + 2, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount24 + 2, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount14 + 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 prevCount13 = CommandBufferCreateCallbackCount;
int prevCount14 = CommandBufferCompleteCallbackCount;
int prevCount12 = kernelSubmitCallbackCount;
int prevCount13 = commandBufferCreateCallbackCount;
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(prevCount13 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
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 prevCount23 = CommandBufferCreateCallbackCount;
int prevCount24 = CommandBufferCompleteCallbackCount;
int prevCount22 = kernelSubmitCallbackCount;
int prevCount23 = commandBufferCreateCallbackCount;
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(prevCount23 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
retVal = clFinish(cmdQ);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(prevCount14 + 2, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount24 + 2, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount14 + 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 prevCount13 = CommandBufferCreateCallbackCount;
int prevCount14 = CommandBufferCompleteCallbackCount;
int prevCount12 = kernelSubmitCallbackCount;
int prevCount13 = commandBufferCreateCallbackCount;
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(prevCount13 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount14, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount12 + 1, kernelSubmitCallbackCount);
EXPECT_EQ(prevCount13 + 1, commandBufferCreateCallbackCount);
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 prevCount23 = CommandBufferCreateCallbackCount;
int prevCount24 = CommandBufferCompleteCallbackCount;
int prevCount22 = kernelSubmitCallbackCount;
int prevCount23 = commandBufferCreateCallbackCount;
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(prevCount23 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount14, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount24, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount22 + 1, kernelSubmitCallbackCount);
EXPECT_EQ(prevCount23 + 1, commandBufferCreateCallbackCount);
EXPECT_EQ(prevCount14, 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(prevCount24 + 2, CommandBufferCompleteCallbackCount);
EXPECT_EQ(prevCount14 + 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 prevCount3 = KernelSubmitCallbackCount;
int prevCount2 = commandBufferCreateCallbackCount;
int prevCount3 = kernelSubmitCallbackCount;
gtpinNotifyKernelSubmit(kernel, pCmdQueue);
EXPECT_EQ(prevCount2 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount3 + 1, KernelSubmitCallbackCount);
EXPECT_EQ(prevCount2 + 1, commandBufferCreateCallbackCount);
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 prevCount23 = KernelSubmitCallbackCount;
int prevCount22 = commandBufferCreateCallbackCount;
int prevCount23 = kernelSubmitCallbackCount;
gtpinNotifyKernelSubmit(kernel2, pCmdQueue);
EXPECT_EQ(prevCount22 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount23 + 1, KernelSubmitCallbackCount);
EXPECT_EQ(prevCount22 + 1, commandBufferCreateCallbackCount);
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 prevCount3 = KernelSubmitCallbackCount;
int prevCount2 = commandBufferCreateCallbackCount;
int prevCount3 = kernelSubmitCallbackCount;
// First kernel submission
gtpinNotifyKernelSubmit(kernel, pCmdQueue);
EXPECT_EQ(prevCount2 + 1, CommandBufferCreateCallbackCount);
EXPECT_EQ(prevCount3 + 1, KernelSubmitCallbackCount);
EXPECT_EQ(prevCount2 + 1, commandBufferCreateCallbackCount);
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(prevCount3 + 2, KernelSubmitCallbackCount);
EXPECT_EQ(prevCount2 + 2, commandBufferCreateCallbackCount);
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) {

4
opencl/test/unit_test/kernel/kernel_tests.cpp
View File

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

8
opencl/test/unit_test/mem_obj/buffer_tests.cpp
View File

@@ -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:

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

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

16
opencl/test/unit_test/mem_obj/image_array_size_tests.cpp
View File

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

6
opencl/test/unit_test/mem_obj/image_redescribe_tests.cpp
View File

@@ -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;
@@ -244,4 +244,4 @@ TEST(ImageRedescribeTestSimple, givenImageWhenItIsRedescribedThenPlaneIsSameAsIn
std::unique_ptr<Image> imageNew(image->redescribe());
ASSERT_NE(nullptr, imageNew);
EXPECT_EQ(image->getPlane(), imageNew->getPlane());
}
}

10
opencl/test/unit_test/mem_obj/image_tests.cpp
View File

@@ -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;
@@ -1955,4 +1955,4 @@ HWTEST_F(ImageAdjustDepthTests, givenSurfaceStateWhenReeaseHelperIsNullprThenOri
ReleaseHelper *releaseHelper = nullptr;
ImageHw<FamilyType>::adjustDepthLimitations(&ss, minArrayElement, renderTargetViewExtent, originalDepth, mipCount, true, releaseHelper);
EXPECT_EQ(ss.getDepth(), originalDepth);
}
}

8
opencl/test/unit_test/mem_obj/image_tiled_tests.cpp
View File

@@ -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(CreateNonTiledImageTest, CreateNonTiledImageTest, testing::ValuesIn(NonTiledImageTypes));
INSTANTIATE_TEST_CASE_P(CreateTiledImageTest, CreateTiledImageTest, testing::ValuesIn(tiledImageTypes));
INSTANTIATE_TEST_CASE_P(CreateNonTiledImageTest, CreateNonTiledImageTest, testing::ValuesIn(nonTiledImageTypes));