intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-22 19:29:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add check if device support Images.

Browse Source 
Related-To: NEO-4675
Change-Id: I0c2b6e04536e45e70748983521e8469dd3dad697
This commit is contained in:
Sebastian Luzynski
2020-05-25 10:21:04 +02:00
committed by sys_ocldev
parent d635eb6300
commit fa3cb35fde
15 changed files with 236 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
opencl/test/unit_test/api/cl_create_image_tests.cpp
View File

@@ -55,6 +55,7 @@ struct clCreateImageTests : public ApiFixture<>,
typedef clCreateImageTests<::testing::Test> clCreateImageTest;
TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
@@ -70,6 +71,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAnd
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingTiledImageThenInvalidOperationErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
@@ -99,6 +101,7 @@ HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingTiledI
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingNonTiledImageThenCreate) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
@@ -127,7 +130,68 @@ HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingNonTil
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImageWithPropertiesINTELThenImageCreatedAndSuccessIsReturned) {
DebugManagerStateRestore stateRestore;
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
mockClDevice.sharedDeviceInfo.imageSupport = CL_FALSE;
cl_bool imageSupportInfo = CL_TRUE;
auto status = clGetDeviceInfo(&mockClDevice, CL_DEVICE_IMAGE_SUPPORT, sizeof(imageSupportInfo), &imageSupportInfo, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
cl_bool expectedValue = CL_FALSE;
EXPECT_EQ(expectedValue, imageSupportInfo);
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc.image_height = 1;
DebugManager.flags.ForceLinearImages.set(true);
auto image = clCreateImageWithPropertiesINTEL(
&mockContext,
nullptr,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithPropertiesAndWithoutThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage(pContext.get(), CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, image);
auto imageWithProperties = clCreateImageWithProperties(pContext.get(), nullptr, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, imageWithProperties);
}
TEST_F(clCreateImageTest, GivenNullContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
auto image = clCreateImageWithProperties(
nullptr,
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndAlignedRowPitchWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 128;
@@ -146,6 +210,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndAlignedRowPitchWhenCreatingImage
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndUnalignedRowPitchWhenCreatingImageThenInvalidImageDescriptotErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 129;
auto image = clCreateImage(
@@ -160,6 +225,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndUnalignedRowPitchWhenCreatingIma
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndSmallRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
@@ -174,6 +240,7 @@ TEST_F(clCreateImageTest, GivenNonNullHostPtrAndSmallRowPitchWhenCreatingImageTh
}
TEST_F(clCreateImageTest, GivenUnrestrictedIntelFlagWhenCreatingImageWithInvalidFlagCombinationThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL;
auto image = clCreateImage(
pContext,
@@ -191,6 +258,7 @@ TEST_F(clCreateImageTest, GivenUnrestrictedIntelFlagWhenCreatingImageWithInvalid
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndNoHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
auto image = clCreateImage(
pContext,
@@ -204,6 +272,7 @@ TEST_F(clCreateImageTest, GivenNotNullHostPtrAndNoHostPtrFlagWhenCreatingImageTh
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = (1 << 12);
auto image = clCreateImage(
pContext,
@@ -221,6 +290,7 @@ TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageThenInvalidValueE
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageFromAnotherImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
auto image = clCreateImage(
pContext,
@@ -255,6 +325,7 @@ TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageFromAnotherImageT
}
TEST_F(clCreateImageTest, GivenInvalidRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 655;
auto image = clCreateImage(
pContext,
@@ -271,6 +342,7 @@ TEST_F(clCreateImageTest, GivenInvalidRowPitchWhenCreatingImageThenInvalidImageD
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndCopyHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
@@ -283,6 +355,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrAndCopyHostPtrFlagWhenCreatingImageThe
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndMemUseHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
@@ -295,6 +368,7 @@ TEST_F(clCreateImageTest, GivenNullHostPtrAndMemUseHostPtrFlagWhenCreatingImageT
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndNonZeroRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
pContext,
@@ -322,9 +396,9 @@ TEST_F(clCreateImageTest, GivenDeviceNotSupportingImagesWhenCreatingImageFromBuf
imageDesc.mem_object = buffer;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
auto image = clCreateImage(
auto image = clCreateImageWithPropertiesINTEL(
pContext.get(),
CL_MEM_READ_WRITE,
nullptr,
&imageFormat,
&imageDesc,
nullptr,
@@ -367,6 +441,7 @@ TEST_F(clCreateImageTest, GivenNonZeroPitchWhenCreatingImageFromBufferThenImageI
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndRowPitchIsNotGreaterThanWidthTimesElementSizeWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 64;
auto image = clCreateImage(
pContext,
@@ -437,6 +512,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenParametersAreCorrec
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectlySet) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
VariableBackup<ImageFunctions::ValidateAndCreateImageFunc> imageCreateBackup{&ImageFunctions::validateAndCreateImage};
cl_mem_properties *properties = nullptr;
@@ -466,6 +542,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectl
}
TEST_F(clCreateImageTest, GivenImageCreatedWithNullPropertiesWhenQueryingPropertiesThenNothingIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
auto image = clCreateImageWithProperties(pContext, nullptr, 0, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(retVal, CL_SUCCESS);
@@ -480,6 +557,7 @@ TEST_F(clCreateImageTest, GivenImageCreatedWithNullPropertiesWhenQueryingPropert
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrectlyStored) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
cl_mem_properties properties[5];
size_t propertiesSize;
@@ -508,6 +586,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrec
typedef clCreateImageTests<::testing::Test> clCreateImageTestYUV;
TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
auto image = clCreateImage(
pContext,
@@ -524,6 +603,7 @@ TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValu
}
TEST_F(clCreateImageTestYUV, Given1DImageTypeWhenCreatingYuvImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
auto image = clCreateImage(
@@ -562,6 +642,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(validFlags));
TEST_P(clCreateImageValidFlags, GivenValidFlagsWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = GetParam();
std::unique_ptr<char[]> ptr;
char *hostPtr = nullptr;
@@ -607,6 +688,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(invalidFlagsCombinations));
TEST_P(clCreateImageInvalidFlags, GivenInvalidFlagsCombinationsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char ptr[10];
imageDesc.image_row_pitch = 128;
@@ -763,7 +845,7 @@ INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
::testing::ValuesIn(invalidFlagsAndParentFlags));
TEST_P(clCreateImageInvalidFlagsAndParentFlagsCombinations, GivenInvalidFlagsAndParentFlagsWhenCreatingImageThenInvalidMemObjectErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
ImageFlags imageFlags = GetParam();
cl_mem_flags parentFlags = imageFlags.parentFlags;
@@ -815,7 +897,7 @@ INSTANTIATE_TEST_CASE_P(validImage2DSizes,
::testing::ValuesIn(validImage2DSizes));
TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
ImageSizes sizes = GetParam();
imageDesc.image_width = sizes.width;
imageDesc.image_height = sizes.height;
@@ -837,6 +919,7 @@ TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsC
typedef clCreateImageTests<::testing::Test> clCreateImage2DTest;
TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
@@ -855,6 +938,7 @@ TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCr
}
TEST_F(clCreateImage2DTest, GivenNoPtrToReturnValueWhenCreating2DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
@@ -886,9 +970,30 @@ TEST_F(clCreateImage2DTest, GivenInvalidContextsWhenCreating2DImageThenInvalidCo
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage2DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage2DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage2D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImage3DTest;
TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
@@ -909,6 +1014,7 @@ TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCr
}
TEST_F(clCreateImage3DTest, GivenNoPtrToReturnValueWhenCreating3DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
@@ -944,6 +1050,28 @@ TEST_F(clCreateImage3DTest, GivenInvalidContextsWhenCreating3DImageThenInvalidCo
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage3DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage3DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage3D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
using clCreateImageWithPropertiesINTELTest = clCreateImageTest;
TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
@@ -1166,13 +1294,7 @@ struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
public ::testing::WithParamInterface<uint32_t /*image type*/> {
void SetUp() override {
clCreateImageFromImageTest::SetUp();
image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
image = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageDesc.mem_object = image;
@@ -1185,7 +1307,7 @@ struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
};
TEST_P(clCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_type = GetParam();
auto imageFromImageObject = clCreateImage(
pContext,

34
opencl/test/unit_test/api/cl_enqueue_copy_buffer_to_image_tests.inl
View File

@@ -7,6 +7,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/buffer_fixture.h"
#include "cl_api_tests.h"
@@ -86,13 +87,8 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidSrcBufferWhenCopyingBufferTo
TEST_F(clEnqueueCopyBufferToImageTests, GivenValidParametersWhenCopyingBufferToImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
cl_mem dstImage = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc,
nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
@@ -119,13 +115,7 @@ typedef clEnqueueCopyBufferToImageTests clEnqueueCopyBufferToImageYUV;
TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToImageThenSuccessIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {2, 2, 0};
@@ -148,13 +138,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToIm
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {1, 2, 0};
@@ -177,13 +161,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyin
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidRegionAndValidYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, dstImage);
const size_t origin[] = {2, 2, 0};

96
opencl/test/unit_test/api/cl_enqueue_copy_image_tests.inl
View File

@@ -99,21 +99,9 @@ TEST_F(clEnqueueCopyImageTests, GivenNullDstBufferWhenCopyingImageThenInvalidMem
TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingImageThenImageFormatMismatchErrorIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
imageFormat.image_channel_order = CL_BGRA;
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@@ -139,20 +127,8 @@ TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingIm
TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@@ -179,20 +155,8 @@ TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessI
typedef clEnqueueCopyImageTests clEnqueueCopyImageYUVTests;
TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSuccessIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@@ -217,20 +181,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSu
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@@ -256,20 +208,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenI
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);
@@ -295,20 +235,8 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenI
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginFor2dImageWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto dstImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
EXPECT_NE(nullptr, dstImage);

32
opencl/test/unit_test/api/cl_enqueue_copy_image_to_buffer_tests.inl
View File

@@ -86,13 +86,7 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidBufferWhenCopyingImageToBuff
TEST_F(clEnqueueCopyImageToBufferTests, GivenValidParametersWhenCopyingImageToBufferThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
@@ -119,13 +113,7 @@ typedef clEnqueueCopyImageToBufferTests clEnqueueCopyImageToBufferYUVTests;
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvImageToBufferThenSuccessIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {2, 2, 0};
@@ -148,13 +136,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvIma
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {1, 2, 0};
@@ -177,13 +159,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImage
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidRegionWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, srcImage);
const size_t origin[] = {2, 2, 0};

32
opencl/test/unit_test/api/cl_enqueue_map_image_tests.inl
View File

@@ -48,13 +48,7 @@ struct clEnqueueMapImageTests : public ApiFixture<>,
};
TEST_F(clEnqueueMapImageTests, GivenValidParametersWhenMappingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -112,13 +106,7 @@ struct clEnqueueMapImageYUVTests : public ApiFixture<>,
};
TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@@ -143,13 +131,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessI
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@@ -174,13 +156,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInval
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidRegionWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

33
opencl/test/unit_test/api/cl_enqueue_read_image_tests.inl
View File

@@ -8,6 +8,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/context/context.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@@ -83,13 +84,7 @@ TEST_F(clEnqueueReadImageTests, GivenNullImageWhenReadingImageThenInvalidMemObje
TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@@ -115,13 +110,7 @@ TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessI
typedef clEnqueueReadImageTests clEnqueueReadImageYuv;
TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@@ -145,13 +134,7 @@ TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsRet
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@@ -175,13 +158,7 @@ TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidVa
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidRegionWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

33
opencl/test/unit_test/api/cl_enqueue_write_image_tests.inl
View File

@@ -8,6 +8,7 @@
#include "opencl/source/command_queue/command_queue.h"
#include "opencl/source/context/context.h"
#include "opencl/source/helpers/surface_formats.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@@ -83,13 +84,7 @@ TEST_F(clEnqueueWriteImageTests, GivenNullImageWhenWritingImageThenInvalidMemObj
TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@@ -115,13 +110,7 @@ TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccess
typedef clEnqueueWriteImageTests clEnqueueWriteImageYUV;
TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSuccessIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};
@@ -145,13 +134,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSucces
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {1, 2, 0};
@@ -174,13 +157,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidV
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidRegionWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
const size_t origin[] = {2, 2, 0};

12
opencl/test/unit_test/api/cl_get_image_info_tests.inl
View File

@@ -37,8 +37,8 @@ struct clGetImageInfoTests : public ApiFixture<>,
imageDesc.num_samples = 0;
imageDesc.mem_object = nullptr;
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc,
nullptr, &retVal);
image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
}
@@ -218,8 +218,7 @@ TEST_F(clGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidth
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
image2 = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat2, &imageDesc2, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
@@ -273,8 +272,7 @@ TEST_F(clGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidth
imageDesc2.num_samples = 0;
imageDesc2.mem_object = nullptr;
image2 = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat2, &imageDesc2,
nullptr, &retVal);
image2 = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat2, &imageDesc2, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image2);
@@ -372,7 +370,7 @@ TEST_F(clGetImageInfoTests, givenMultisampleCountForMcsWhenAskingForRowPitchThen
size_t receivedRowPitch = 0;
clReleaseMemObject(image);
image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto imageObj = castToObject<Image>(image);
auto formatInfo = imageObj->getSurfaceFormatInfo();

7
opencl/test/unit_test/api/cl_set_mem_object_destructor_callback_tests.inl
View File

@@ -6,6 +6,7 @@
*/
#include "opencl/source/context/context.h"
#include "opencl/source/mem_obj/image.h"
#include "cl_api_tests.h"
@@ -60,8 +61,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenNullMemObjWhenSettingMemObjCa
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhenSettingMemObjCallbackThenSuccessIsReturned) {
auto image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat,
&imageDesc, nullptr, &retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, destructorCallback, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -72,8 +72,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhe
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
auto image = clCreateImage(pContext, CL_MEM_READ_WRITE, &imageFormat,
&imageDesc, nullptr, &retVal);
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);