Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: correct variable naming

Browse Source 
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Artur Harasimiuk
2022-05-16 15:15:59 +00:00
committed by Compute-Runtime-Automation
parent 06517f429f
commit 4c98e98011
13 changed files with 437 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
opencl/test/unit_test/api/cl_enqueue_task_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -51,11 +51,11 @@ TEST_F(EnqueueTaskWithRequiredWorkGroupSize, GivenRequiredWorkGroupSizeWhenEnque
cl_uint numEventsInWaitList = 0;
cl_event *eventWaitList = nullptr;
cl_event *event = nullptr;
cl_command_queue command_queue = static_cast<cl_command_queue>(pCmdQ);
cl_command_queue commandQueue = static_cast<cl_command_queue>(pCmdQ);
cl_kernel kernel = static_cast<cl_kernel>(pMultiDeviceKernel);
retVal = clEnqueueTask(
command_queue,
commandQueue,
kernel,
numEventsInWaitList,
eventWaitList,

74
opencl/test/unit_test/api/cl_get_device_and_host_timer.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -36,85 +36,85 @@ typedef api_tests clGetHostTimerTest;
namespace ULT {
TEST_F(clGetDeviceAndHostTimerTest, GivenNullDeviceWhenGettingDeviceAndHostTimerThenInvalidDeviceErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
nullptr,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenNullHostTimerWhenGettingDeviceAndHostTimerThenInvalidValueErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong deviceTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
testedClDevice,
&device_timestamp,
&deviceTimestamp,
nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenNullDevicesTimerWhenGettingDeviceAndHostTimerThenInvalidValueErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
testedClDevice,
nullptr,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenValidOSTimeWhenGettingDeviceAndHostTimerThenSuccessIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new MockOSTime());
retVal = clGetDeviceAndHostTimer(
mDev,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_GT(device_timestamp, zero_timestamp);
EXPECT_GT(host_timestamp, zero_timestamp);
EXPECT_GT(deviceTimestamp, zeroTimestamp);
EXPECT_GT(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
delete mDev;
}
TEST_F(clGetDeviceAndHostTimerTest, GivenInvalidOSTimeWhenGettingDeviceAndHostTimerThenOutOfResourcesErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new FailOSTime());
retVal = clGetDeviceAndHostTimer(
mDev,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_EQ(device_timestamp, zero_timestamp);
EXPECT_EQ(host_timestamp, zero_timestamp);
EXPECT_EQ(deviceTimestamp, zeroTimestamp);
EXPECT_EQ(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_OUT_OF_RESOURCES);
delete mDev;
}
TEST_F(clGetHostTimerTest, GivenNullDeviceWhenGettingHostTimerThenInvalidDeviceErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetHostTimer(
nullptr,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
@ -128,46 +128,46 @@ TEST_F(clGetHostTimerTest, GivenNullHostTimerWhenGettingHostTimerThenInvalidValu
}
TEST_F(clGetHostTimerTest, GivenCorrectParametersWhenGettingHostTimerThenSuccessIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
retVal = clGetHostTimer(
testedClDevice,
&host_timestamp);
&hostTimestamp);
EXPECT_GE(host_timestamp, zero_timestamp);
EXPECT_GE(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
}
TEST_F(clGetHostTimerTest, GivenValidOSTimeWhenGettingHostTimerThenSuccessIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new MockOSTime());
retVal = clGetHostTimer(
mDev,
&host_timestamp);
&hostTimestamp);
EXPECT_GE(host_timestamp, zero_timestamp);
EXPECT_GE(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
delete mDev;
}
TEST_F(clGetHostTimerTest, GivenInvalidOSTimeWhenGettingHostTimerThenOutOfResourcesErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new FailOSTime());
retVal = clGetHostTimer(
mDev,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(host_timestamp, zero_timestamp);
EXPECT_EQ(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_OUT_OF_RESOURCES);
delete mDev;

94
opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl
View File

@ -42,18 +42,18 @@ cl_int ProfilingInfo[] = {
TEST_F(clEventProfilingTests, GivenInvalidParamNameWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_int retVal = CL_PROFILING_INFO_NOT_AVAILABLE;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
retVal = clGetEventProfilingInfo(event,
0,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
delete pEvent;
@ -80,18 +80,18 @@ TEST_F(clEventProfilingTests, GivenInvalidParametersWhenGettingEventProfilingInf
TEST_F(clEventProfilingTests, GivenInvalidParamValueSizeWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_int retVal = CL_PROFILING_INFO_NOT_AVAILABLE;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
retVal = clGetEventProfilingInfo(event,
ProfilingInfo[0],
param_value_size - 1,
&param_value,
&param_value_size_ret);
paramValueSize - 1,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
delete pEvent;
@ -100,18 +100,18 @@ TEST_F(clEventProfilingTests, GivenInvalidParamValueSizeWhenGettingEventProfilin
TEST_F(clEventProfilingTests, GivenValidParametersWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
for (auto infoId : ::ProfilingInfo) {
cl_int retVal = clGetEventProfilingInfo(event,
infoId,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_SUCCESS, retVal);
}
@ -121,16 +121,16 @@ TEST_F(clEventProfilingTests, GivenValidParametersWhenGettingEventProfilingInfoT
TEST_F(clEventProfilingTests, GivenNullParamValueSizeRetWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
cl_int retVal = clGetEventProfilingInfo(event,
ProfilingInfo[0],
param_value_size,
&param_value,
paramValueSize,
&paramValue,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -145,7 +145,7 @@ TEST_F(clEventProfilingTests, GivenNullEventWhenGettingEventProfilingInfoThenInv
TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
size_t param_value_size = 0;
size_t paramValueSize = 0;
pEvent->setStatus(CL_COMPLETE);
pEvent->setProfilingEnabled(true);
@ -153,7 +153,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettin
cl_event event = (cl_event)pEvent;
cl_int retVal = clGetEventProfilingInfo(event,
CL_PROFILING_COMMAND_QUEUED,
param_value_size,
paramValueSize,
nullptr,
nullptr);
@ -164,7 +164,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettin
TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
size_t param_value_size = sizeof(cl_ulong);
size_t paramValueSize = sizeof(cl_ulong);
pEvent->setStatus(CL_COMPLETE);
pEvent->setProfilingEnabled(true);
@ -172,7 +172,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGet
cl_event event = (cl_event)pEvent;
cl_int retVal = clGetEventProfilingInfo(event,
CL_PROFILING_COMMAND_QUEUED,
param_value_size,
paramValueSize,
nullptr,
nullptr);
@ -183,17 +183,17 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGet
TEST_F(clEventProfilingTests, GivenUserEventWhenGettingEventProfilingInfoThenProfilingInfoNotAvailableErrorIsReturned) {
UserEvent *ue = new UserEvent();
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_event event = (cl_event)ue;
for (auto infoId : ::ProfilingInfo) {
cl_int retVal = clGetEventProfilingInfo(event,
infoId,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, retVal);
}
delete ue;
@ -225,14 +225,14 @@ TEST_F(clEventProfilingTests, GivenStartTimeGreaterThenEndTimeWhenGettingDeltaTh
TEST_F(clEventProfilingTests, givenTimestampThatOverlapWhenGetDeltaIsCalledThenProperDeltaIsComputed) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
cl_ulong TimeMax = maxNBitValue(pDevice->getHardwareInfo().capabilityTable.kernelTimestampValidBits);
cl_ulong timeMax = maxNBitValue(pDevice->getHardwareInfo().capabilityTable.kernelTimestampValidBits);
cl_ulong realDelta = 10;
cl_ulong startTime = TimeMax - realDelta;
cl_ulong startTime = timeMax - realDelta;
cl_ulong endTime = 2;
cl_ulong Delta = 0;
Delta = pEvent->getDelta(startTime, endTime);
EXPECT_EQ(realDelta + endTime, Delta);
cl_ulong delta = 0;
delta = pEvent->getDelta(startTime, endTime);
EXPECT_EQ(realDelta + endTime, delta);
delete pEvent;
}
@ -244,28 +244,28 @@ TEST_F(clEventProfilingTests, GivenProfilingDisabledWhenCalculatingProfilingData
TEST_F(clEventProfilingTests, GivenProfilingEnabledWhenCalculatingProfilingDataThenFalseIsNotReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
cl_bool Result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), Result);
cl_bool result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), result);
pEvent->setProfilingEnabled(true);
Result = pEvent->isProfilingEnabled();
EXPECT_NE(((cl_bool)CL_FALSE), Result);
result = pEvent->isProfilingEnabled();
EXPECT_NE(((cl_bool)CL_FALSE), result);
delete pEvent;
}
TEST_F(clEventProfilingTests, GivenProfilingEnabledAndUserEventsWhenCalculatingProfilingDataThenFalseIsReturned) {
Event *pEvent = new UserEvent();
cl_bool Result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), Result);
cl_bool result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), result);
delete pEvent;
}
TEST_F(clEventProfilingTests, GivenPerfCountersEnabledWhenCheckingPerfCountersThenTrueIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
bool Result = pEvent->isPerfCountersEnabled();
EXPECT_FALSE(Result);
bool result = pEvent->isPerfCountersEnabled();
EXPECT_FALSE(result);
pEvent->setPerfCountersEnabled(true);
Result = pEvent->isPerfCountersEnabled();
EXPECT_TRUE(Result);
result = pEvent->isPerfCountersEnabled();
EXPECT_TRUE(result);
delete pEvent;
}

20
opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -76,7 +76,7 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFrom
}
TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettingKernelWorkGroupInfoThenCorrectSpillMemSizeIsReturned) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -90,18 +90,18 @@ TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettin
pDevice,
CL_KERNEL_SPILL_MEM_SIZE_INTEL,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
EXPECT_EQ(param_value, scratchSpaceSize);
EXPECT_EQ(paramValue, scratchSpaceSize);
}
using matcher = IsWithinProducts<IGFX_SKYLAKE, IGFX_DG1>;
HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -112,17 +112,17 @@ HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocatio
pDevice,
CL_KERNEL_PRIVATE_MEM_SIZE,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(sizeof(cl_ulong), paramValueSizeRet);
EXPECT_EQ(1024U, param_value);
EXPECT_EQ(1024U, paramValue);
}
TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenZeroIsReturned) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -132,12 +132,12 @@ TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocatio
pDevice,
CL_KERNEL_PRIVATE_MEM_SIZE,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
EXPECT_EQ(param_value, 0u);
EXPECT_EQ(paramValue, 0u);
}
static cl_kernel_work_group_info paramNames[] = {

46
opencl/test/unit_test/api/cl_intel_accelerator_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -52,11 +52,11 @@ struct IntelAcceleratorTestWithValidDescriptor : IntelAcceleratorTest {
};
TEST_F(IntelAcceleratorTestWithValidDescriptor, GivenInvalidAcceleratorTypeWhenCreatingAcceleratorThenClInvalidAcceleratorTypeIntelErrorIsReturned) {
auto INVALID_ACCELERATOR_TYPE = static_cast<cl_accelerator_type_intel>(0xEEEEEEEE);
auto invalidAcceleratorType = static_cast<cl_accelerator_type_intel>(0xEEEEEEEE);
accelerator = clCreateAcceleratorINTEL(
pContext,
INVALID_ACCELERATOR_TYPE,
invalidAcceleratorType,
sizeof(cl_motion_estimation_desc_intel),
&desc,
&retVal);
@ -161,42 +161,42 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenClAcceleratorReferenceCountIntelWhenGet
}
TEST_F(IntelAcceleratorGetInfoTest, GivenClAcceleratorReferenceCountIntelWhenGettingAcceleratorInfoThenParamValueIsOne) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
nullptr);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceleratorInfoThenCorrectValuesAreReturned) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint) + 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(sizeof(cl_uint), param_value_size_ret);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenShortForDescriptorSizeWhenGettingAcceleratorInfoThenClInvalidValueErrorIsReturned) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint) - 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_INVALID_VALUE, result);
@ -215,7 +215,7 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenZeroForDescriptorSizeGivenLongForDescri
}
TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAcceleratorInfoThenParamValueIsTwo) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clRetainAcceleratorINTEL(accelerator);
ASSERT_EQ(CL_SUCCESS, result);
@ -224,11 +224,11 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAccel
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(2u, param_value);
EXPECT_EQ(2u, paramValue);
result = clReleaseAcceleratorINTEL(accelerator);
@ -238,11 +238,11 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAccel
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenNullPtrForParamValueWhenGettingAcceleratorInfoThenClSuccessIsReturned) {
@ -258,13 +258,13 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenNullPtrForParamValueWhenGettingAccelera
}
TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceleratorContextInfoThenCorrectValuesAreReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context) + 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
@ -272,30 +272,30 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceler
}
TEST_F(IntelAcceleratorGetInfoTest, GivenAcceleratorContextIntelWhenGettingAcceleratorInfoThenCorrectValuesAreReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(sizeof(cl_context), param_value_size_ret);
cl_context referenceContext = static_cast<cl_context>(pContext);
EXPECT_EQ(referenceContext, param_value);
EXPECT_EQ(referenceContext, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenShortForDescriptorSizeWhenGettingAcceleratorContextInfoThenClInvalidValueErrorIsReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context) - 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_INVALID_VALUE, result);

44
opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -102,12 +102,12 @@ TEST_F(clSetKernelExecInfoTests, GivenDeviceNotSupportingSvmWhenSettingKernelExe
TEST_F(clSetKernelExecInfoTests, GivenNullParamValueWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void **pSvmPtrList = nullptr;
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -116,12 +116,12 @@ TEST_F(clSetKernelExecInfoTests, GivenNullParamValueWhenSettingAdditionalKernelI
TEST_F(clSetKernelExecInfoTests, GivenNullPointerInParamValueWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {nullptr};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -130,12 +130,12 @@ TEST_F(clSetKernelExecInfoTests, GivenNullPointerInParamValueWhenSettingAddition
TEST_F(clSetKernelExecInfoTests, GivenParamSizeZeroWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 0;
size_t svmPtrListSizeInBytes = 0;
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -144,12 +144,12 @@ TEST_F(clSetKernelExecInfoTests, GivenParamSizeZeroWhenSettingAdditionalKernelIn
TEST_F(clSetKernelExecInfoTests, GivenInvalidParamSizeWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = (size_t)(-1);
size_t svmPtrListSizeInBytes = (size_t)(-1);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -157,12 +157,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidParamSizeWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenInvalidParamNameWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
0, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -170,12 +170,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidParamNameWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenInvalidOperationWhenSettingAdditionalKernelInfoThenInvalidOperationErrorIsReturned) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
@ -184,12 +184,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidOperationWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenValidPointerListWithOnePointerWhenSettingAdditionalKernelInfoThenSuccessIsReturned) {
if (svmCapabilities != 0) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -207,12 +207,12 @@ TEST_F(clSetKernelExecInfoTests, GivenValidPointerListWithMultiplePointersWhenSe
EXPECT_NE(nullptr, ptrSvm2);
void *pSvmPtrList[] = {ptrSvm, ptrSvm1, ptrSvm2};
size_t SvmPtrListSizeInBytes = 3 * sizeof(void *);
size_t svmPtrListSizeInBytes = 3 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -234,12 +234,12 @@ TEST_F(clSetKernelExecInfoTests, givenReadOnlySvmPtrListWhenUsedAsKernelPointers
EXPECT_NE(nullptr, ptrSvm2);
void *pSvmPtrList[] = {ptrSvm1, ptrSvm2};
size_t SvmPtrListSizeInBytes = 2 * sizeof(void *);
size_t svmPtrListSizeInBytes = 2 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -255,12 +255,12 @@ TEST_F(clSetKernelExecInfoTests, givenReadOnlySvmPtrListWhenUsedAsKernelPointers
TEST_F(clSetKernelExecInfoTests, GivenMultipleSettingKernelInfoOperationsWhenSettingAdditionalKernelInfoThenSuccessIsReturned) {
if (svmCapabilities != 0) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -270,7 +270,7 @@ TEST_F(clSetKernelExecInfoTests, GivenMultipleSettingKernelInfoOperationsWhenSet
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);

80
opencl/test/unit_test/api/cl_svm_alloc_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -53,10 +53,10 @@ TEST(clSVMAllocTest, givenPlatformWithoutDevicesWhenClSVMAllocIsCalledThenDevice
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0u, platform()->getNumDevices());
auto SVMPtr = clSVMAlloc(context.get(), 0u, 4096, 128);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(context.get(), 0u, 4096, 128);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(context.get(), SVMPtr);
clSVMFree(context.get(), svmPtr);
}
TEST_P(clSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAllocated) {
@ -68,28 +68,28 @@ TEST_P(clSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAlloc
if (flags & CL_MEM_SVM_FINE_GRAIN_BUFFER) {
//fg svm flag, fg svm support - expected success
if (devInfo.svmCapabilities & CL_DEVICE_SVM_FINE_GRAIN_BUFFER) {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, SVMPtr);
clSVMFree(pContext, svmPtr);
}
//fg svm flag no fg svm support
else {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
}
//no fg svm flag, svm support - expected success
else {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, SVMPtr);
clSVMFree(pContext, svmPtr);
}
} else {
//no svm support -expected fail
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
};
@ -123,32 +123,32 @@ TEST_P(clSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAlloc
HardwareInfo *pHwInfo = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[testedRootDeviceIndex]->getMutableHardwareInfo();
cl_mem_flags flags = GetParam();
void *SVMPtr = nullptr;
void *svmPtr = nullptr;
//1: no svm - no flags supported
pHwInfo->capabilityTable.ftrSvm = false;
pHwInfo->capabilityTable.ftrSupportsCoherency = false;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_EQ(nullptr, SVMPtr);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_EQ(nullptr, svmPtr);
//2: coarse svm - normal flags supported
pHwInfo->capabilityTable.ftrSvm = true;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
if (flags & CL_MEM_SVM_FINE_GRAIN_BUFFER) {
//fg svm flags not supported
EXPECT_EQ(nullptr, SVMPtr);
EXPECT_EQ(nullptr, svmPtr);
} else {
//no fg svm flags supported
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
//3: fg svm - all flags supported
pHwInfo->capabilityTable.ftrSupportsCoherency = true;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
};
struct clSVMAllocInvalidFlagsTests : public clSVMAllocTemplateTests {
@ -157,8 +157,8 @@ struct clSVMAllocInvalidFlagsTests : public clSVMAllocTemplateTests {
TEST_P(clSVMAllocInvalidFlagsTests, GivenInvalidFlagsWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = GetParam();
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
};
cl_mem_flags SVMAllocInvalidFlags[] = {
@ -174,23 +174,23 @@ INSTANTIATE_TEST_CASE_P(
TEST_F(clSVMAllocTests, GivenNullContextWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(nullptr /* cl_context */, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(nullptr /* cl_context */, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenZeroSizeWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 0 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 0 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenZeroAlignmentWhenAllocatingSvmThenSvmIsAllocated) {
const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
if (devInfo.svmCapabilities != 0) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
}
@ -243,21 +243,21 @@ TEST_F(clSVMAllocTests, GivenUnalignedSizeAndDefaultAlignmentWhenAllocatingSvmTh
const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
if (devInfo.svmCapabilities != 0) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4095 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4095 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
}
TEST_F(clSVMAllocTests, GivenAlignmentNotPowerOfTwoWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 129 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 129 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenAlignmentTooLargeWhenAllocatingSvmThenSvmIsNotAllocated) {
auto SVMPtr = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 4096 /* Size */, 4096 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 4096 /* Size */, 4096 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
};
TEST_F(clSVMAllocTests, GivenForcedFineGrainedSvmWhenCreatingSvmAllocThenAllocationIsCreated) {