Add error code for get device info relative to images

if image are not supported Related-To: NEO-3931 Change-Id: I527da2dc857cd15dae6535dd389378511eb71b6d Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
2026-01-04 15:53:45 +08:00 · 2020-01-14 16:36:53 +01:00
parent 318d9620ae
commit 1b072cf170
6 changed files with 558 additions and 59 deletions
--- a/unit_tests/device/get_device_info_size_tests.cpp
+++ b/unit_tests/device/get_device_info_size_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2019 Intel Corporation
+ * Copyright (C) 2017-2020 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -53,15 +53,6 @@ std::pair<uint32_t, size_t> deviceInfoParams2[] = {
    {CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong)},
    {CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, sizeof(size_t)},
    //    {CL_DEVICE_IL_VERSION, sizeof(char[])},
-    {CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t)},
-    {CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t)},
-    {CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t)},
-    {CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t)},
-    {CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t)},
-    {CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, sizeof(cl_uint)},
-    {CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof(size_t)},
-    {CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, sizeof(size_t)},
-    {CL_DEVICE_IMAGE_PITCH_ALIGNMENT, sizeof(cl_uint)},
    {CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool)},
    {CL_DEVICE_LINKER_AVAILABLE, sizeof(cl_bool)},
    {CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong)},
@@ -77,13 +68,10 @@ std::pair<uint32_t, size_t> deviceInfoParams2[] = {
    {CL_DEVICE_MAX_ON_DEVICE_QUEUES, sizeof(cl_uint)},
    {CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(size_t)},
    {CL_DEVICE_MAX_PIPE_ARGS, sizeof(cl_uint)},
-    {CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint)},
-    {CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, sizeof(cl_uint)},
    {CL_DEVICE_MAX_SAMPLERS, sizeof(cl_uint)},
    {CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t)},
    {CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(cl_uint)},
    {CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t[3])},
-    {CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint)},
    {CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof(cl_uint)},
    //    {CL_DEVICE_NAME, sizeof(char[])},
    {CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, sizeof(cl_uint)},
@@ -138,6 +126,93 @@ INSTANTIATE_TEST_CASE_P(
    GetDeviceInfoSize,
    testing::ValuesIn(deviceInfoParams2));

+struct GetDeviceInfoForImage : public GetDeviceInfoSize {};
+
+TEST_P(GetDeviceInfoForImage, imageInfoSizeIsValid) {
+    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    if (!device->getDeviceInfo().imageSupport) {
+        GTEST_SKIP();
+    }
+    size_t sizeReturned = 0;
+    auto retVal = device->getDeviceInfo(
+        param.first,
+        0,
+        nullptr,
+        &sizeReturned);
+    if (CL_SUCCESS != retVal) {
+        ASSERT_EQ(CL_SUCCESS, retVal) << " param = " << param.first;
+    }
+    ASSERT_NE(0u, sizeReturned);
+    EXPECT_EQ(param.second, sizeReturned);
+}
+
+TEST_P(GetDeviceInfoForImage, whenImageAreNotSupportedThenClInvalidValueIsReturned) {
+    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    if (device->getDeviceInfo().imageSupport) {
+        GTEST_SKIP();
+    }
+    size_t sizeReturned = 0;
+    auto retVal = device->getDeviceInfo(
+        param.first,
+        0,
+        nullptr,
+        &sizeReturned);
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST_P(GetDeviceInfoForImage, givenInfoImageParamsWhenCallGetDeviceInfoForImageThenSizeIsValidAndTrueReturned) {
+    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    size_t srcSize = 0;
+    size_t retSize = 0;
+    const void *src = nullptr;
+    auto retVal = device->getDeviceInfoForImage(
+        param.first,
+        src,
+        srcSize,
+        retSize);
+    EXPECT_TRUE(retVal);
+    ASSERT_NE(0u, srcSize);
+    EXPECT_EQ(param.second, srcSize);
+    EXPECT_EQ(param.second, retSize);
+}
+
+TEST(GetDeviceInfoForImage, givenNotImageParamWhenCallGetDeviceInfoForImageThenSizeIsNotValidAndFalseReturned) {
+    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    size_t srcSize = 0;
+    size_t retSize = 0;
+    const void *src = nullptr;
+    cl_device_info notImageParam = CL_DEVICE_ADDRESS_BITS;
+    size_t paramSize = sizeof(cl_uint);
+    auto retVal = device->getDeviceInfoForImage(
+        notImageParam,
+        src,
+        srcSize,
+        retSize);
+    EXPECT_FALSE(retVal);
+    EXPECT_EQ(0u, srcSize);
+    EXPECT_NE(paramSize, srcSize);
+    EXPECT_NE(paramSize, retSize);
+}
+std::pair<uint32_t, size_t> deviceInfoImageParams[] = {
+    {CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t)},
+    {CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t)},
+    {CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t)},
+    {CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t)},
+    {CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t)},
+    {CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, sizeof(cl_uint)},
+    {CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, sizeof(size_t)},
+    {CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, sizeof(size_t)},
+    {CL_DEVICE_IMAGE_PITCH_ALIGNMENT, sizeof(cl_uint)},
+    {CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint)},
+    {CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, sizeof(cl_uint)},
+    {CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint)},
+};
+
+INSTANTIATE_TEST_CASE_P(
+    Device_,
+    GetDeviceInfoForImage,
+    testing::ValuesIn(deviceInfoImageParams));
+
 TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForDeviceVersionThenProperSizeIsReturned) {
    auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    size_t sizeReturned = 0;
@@ -158,4 +233,4 @@ TEST(DeviceInfoTests, givenDefaultDeviceWhenQueriedForDeviceVersionThenProperSiz
        nullptr);

    EXPECT_EQ(CL_SUCCESS, retVal);
-}
+}
--- a/unit_tests/device/get_device_info_tests.cpp
+++ b/unit_tests/device/get_device_info_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2019 Intel Corporation
+ * Copyright (C) 2017-2020 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -42,9 +42,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, GetDeviceInfoMemCapabilitiesTest, GivenValidParamete
    check(params);
 }

-TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabled) {
+TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabledAndSupportImageEnabled) {
    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
-
+    device->deviceInfo.imageSupport = true;
    device->deviceInfo.nv12Extension = false;
    uint32_t value;

@@ -65,9 +65,9 @@ TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtens
    EXPECT_EQ(CL_INVALID_VALUE, retVal);
 }

-TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarYuvExtensionEnabled) {
+TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarYuvExtensionEnabledAndSupportImageEnabled) {
    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
-
+    device->deviceInfo.imageSupport = true;
    device->deviceInfo.nv12Extension = true;
    size_t value = 0;

@@ -90,6 +90,342 @@ TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsCorrectValuesWhenPlanarY
    EXPECT_EQ(16352u, value);
 }

+TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionDisabledAndSupportImageDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    device->deviceInfo.imageSupport = false;
+    device->deviceInfo.nv12Extension = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL,
+        4,
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL,
+        4,
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, devicePlanarYuvMaxWidthHeightReturnsErrorWhenPlanarYuvExtensionEnabledAndSupportImageDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    device->deviceInfo.imageSupport = false;
+    device->deviceInfo.nv12Extension = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL,
+        4,
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL,
+        4,
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImage2dMaxWidthHeightReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE2D_MAX_WIDTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE2D_MAX_HEIGHT,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImage2dMaxWidthHeightReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE2D_MAX_WIDTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE2D_MAX_HEIGHT,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImage3dMaxWidthHeightDepthReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_WIDTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_HEIGHT,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_DEPTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImage3dMaxWidthHeightDepthReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_WIDTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_HEIGHT,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE3D_MAX_DEPTH,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxArgsReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_READ_IMAGE_ARGS,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_WRITE_IMAGE_ARGS,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxArgsReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_READ_IMAGE_ARGS,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    retVal = device->getDeviceInfo(
+        CL_DEVICE_MAX_WRITE_IMAGE_ARGS,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageBaseAddressAlignmentReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageBaseAddressAlignmentReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxArraySizeReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxArraySizeReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxBufferSizeReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImageMaxBufferSizeReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
+        sizeof(size_t),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImagePtichAlignmentReturnsErrorWhenImageSupportDisabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = false;
+    uint32_t value;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_PITCH_ALIGNMENT,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_INVALID_VALUE, retVal);
+}
+
+TEST(GetDeviceInfo, clDeviceImagePtichAlignmentReturnsCorrectValuesWhenImageSupportEnabled) {
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    device->deviceInfo.imageSupport = true;
+    size_t value = 0;
+
+    auto retVal = device->getDeviceInfo(
+        CL_DEVICE_IMAGE_PITCH_ALIGNMENT,
+        sizeof(cl_uint),
+        &value,
+        nullptr);
+
+    EXPECT_EQ(CL_SUCCESS, retVal);
+}
+
 TEST(GetDeviceInfo, numSimultaneousInterops) {
    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    device->simultaneousInterops = {0};
@@ -195,15 +531,6 @@ cl_device_info deviceInfoParams[] = {
    CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE,
    CL_DEVICE_HALF_FP_CONFIG,
    CL_DEVICE_HOST_UNIFIED_MEMORY,
-    CL_DEVICE_IMAGE2D_MAX_HEIGHT,
-    CL_DEVICE_IMAGE2D_MAX_WIDTH,
-    CL_DEVICE_IMAGE3D_MAX_DEPTH,
-    CL_DEVICE_IMAGE3D_MAX_HEIGHT,
-    CL_DEVICE_IMAGE3D_MAX_WIDTH,
-    CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT,
-    CL_DEVICE_IMAGE_MAX_ARRAY_SIZE,
-    CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
-    CL_DEVICE_IMAGE_PITCH_ALIGNMENT,
    CL_DEVICE_IMAGE_SUPPORT,
    CL_DEVICE_LINKER_AVAILABLE,
    CL_DEVICE_LOCAL_MEM_SIZE,
@@ -219,13 +546,10 @@ cl_device_info deviceInfoParams[] = {
    CL_DEVICE_MAX_ON_DEVICE_QUEUES,
    CL_DEVICE_MAX_PARAMETER_SIZE,
    CL_DEVICE_MAX_PIPE_ARGS,
-    CL_DEVICE_MAX_READ_IMAGE_ARGS,
-    CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS,
    CL_DEVICE_MAX_SAMPLERS,
    CL_DEVICE_MAX_WORK_GROUP_SIZE,
    CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
    CL_DEVICE_MAX_WORK_ITEM_SIZES,
-    CL_DEVICE_MAX_WRITE_IMAGE_ARGS,
    CL_DEVICE_MEM_BASE_ADDR_ALIGN,
    CL_DEVICE_ME_VERSION_INTEL,
    CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE,