diff --git a/opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp b/opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
index 786ce6676e..0b23029ee8 100644
--- a/opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
+++ b/opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -273,51 +273,6 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDefaultDeviceQueueWithoutQueu
     EXPECT_EQ(retVal, CL_INVALID_VALUE);
 }
 
-HWCMDTEST_F(IGFX_GEN8_CORE, clCreateCommandQueueWithPropertiesApi, GivenNumberOfDevicesGreaterThanMaxWhenCreatingCommandQueueWithPropertiesThenOutOfResourcesErrorIsReturned) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pContext);
-    cl_int retVal = CL_SUCCESS;
-    auto pDevice = castToObject<ClDevice>(testedClDevice);
-    cl_queue_properties odq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE, 0};
-
-    auto cmdq1 = clCreateCommandQueueWithProperties(pContext, testedClDevice, odq, &retVal);
-    EXPECT_NE(nullptr, cmdq1);
-    EXPECT_EQ(retVal, CL_SUCCESS);
-
-    auto cmdq2 = clCreateCommandQueueWithProperties(pContext, testedClDevice, odq, &retVal);
-    if (pDevice->getDeviceInfo().maxOnDeviceQueues > 1) {
-        EXPECT_NE(nullptr, cmdq2);
-        EXPECT_EQ(retVal, CL_SUCCESS);
-    } else {
-        EXPECT_EQ(nullptr, cmdq2);
-        EXPECT_EQ(retVal, CL_OUT_OF_RESOURCES);
-    }
-
-    clReleaseCommandQueue(cmdq1);
-    if (cmdq2) {
-        clReleaseCommandQueue(cmdq2);
-    }
-}
-
-HWCMDTEST_F(IGFX_GEN8_CORE, clCreateCommandQueueWithPropertiesApi, GivenFailedAllocationWhenCreatingCommandQueueWithPropertiesThenOutOfHostMemoryErrorIsReturned) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pContext);
-    InjectedFunction method = [this](size_t failureIndex) {
-        cl_queue_properties ooq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT, 0};
-        auto retVal = CL_INVALID_VALUE;
-
-        auto cmdq = clCreateCommandQueueWithProperties(pContext, testedClDevice, ooq, &retVal);
-
-        if (MemoryManagement::nonfailingAllocation == failureIndex) {
-            EXPECT_EQ(CL_SUCCESS, retVal);
-            EXPECT_NE(nullptr, cmdq);
-            clReleaseCommandQueue(cmdq);
-        } else {
-            EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, retVal) << "for allocation " << failureIndex;
-            EXPECT_EQ(nullptr, cmdq);
-        }
-    };
-    injectFailureOnIndex(method, 0);
-}
-
 TEST_F(clCreateCommandQueueWithPropertiesApi, GivenHighPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
     cl_int retVal = CL_SUCCESS;
     cl_queue_properties ondevice[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_HIGH_KHR, 0};
@@ -455,33 +410,6 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithVariou
     }
 }
 
-TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceQueueCreatedWithVariousPropertiesWhenQueryingPropertiesArrayThenCorrectValuesAreReturned) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pContext);
-
-    cl_int retVal = CL_SUCCESS;
-    cl_queue_properties propertiesArray[5];
-    size_t propertiesArraySize;
-
-    std::vector<std::vector<uint64_t>> propertiesToTest{
-        {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0},
-        {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_SIZE, 16, 0}};
-
-    for (auto properties : propertiesToTest) {
-        auto commandQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, properties.data(), &retVal);
-        EXPECT_EQ(CL_SUCCESS, retVal);
-
-        retVal = clGetCommandQueueInfo(commandQueue, CL_QUEUE_PROPERTIES_ARRAY,
-                                       sizeof(propertiesArray), propertiesArray, &propertiesArraySize);
-        EXPECT_EQ(CL_SUCCESS, retVal);
-        EXPECT_EQ(properties.size() * sizeof(cl_queue_properties), propertiesArraySize);
-        for (size_t i = 0; i < properties.size(); i++) {
-            EXPECT_EQ(properties[i], propertiesArray[i]);
-        }
-
-        clReleaseCommandQueue(commandQueue);
-    }
-}
-
 TEST_F(clCreateCommandQueueWithPropertiesApi, givenQueueFamilySelectedAndNotIndexWhenCreatingQueueThenFail) {
     cl_queue_properties queueProperties[] = {
         CL_QUEUE_FAMILY_INTEL,
diff --git a/opencl/test/unit_test/aub_tests/gen11/execution_model/CMakeLists.txt b/opencl/test/unit_test/aub_tests/gen11/execution_model/CMakeLists.txt
deleted file mode 100644
index 12fd1c7462..0000000000
--- a/opencl/test/unit_test/aub_tests/gen11/execution_model/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-#
-# Copyright (C) 2019-2021 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-target_sources(igdrcl_aub_tests PRIVATE
-               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-               ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen11.cpp
-)
diff --git a/opencl/test/unit_test/aub_tests/gen11/execution_model/enqueue_parent_kernel_tests_gen11.cpp b/opencl/test/unit_test/aub_tests/gen11/execution_model/enqueue_parent_kernel_tests_gen11.cpp
deleted file mode 100644
index ac2de59c17..0000000000
--- a/opencl/test/unit_test/aub_tests/gen11/execution_model/enqueue_parent_kernel_tests_gen11.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (C) 2019-2021 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "shared/source/built_ins/built_ins.h"
-#include "shared/test/common/test_macros/test.h"
-
-#include "opencl/source/mem_obj/image.h"
-#include "opencl/source/sampler/sampler.h"
-#include "opencl/test/unit_test/aub_tests/fixtures/aub_parent_kernel_fixture.h"
-#include "opencl/test/unit_test/fixtures/buffer_fixture.h"
-#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
-
-using namespace NEO;
-
-typedef AUBParentKernelFixture GEN11AUBParentKernelFixture;
-
-GEN11TEST_F(GEN11AUBParentKernelFixture, WhenEnqueuingParentKernelThenExpectationsMet) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pClDevice);
-
-    ASSERT_NE(nullptr, pKernel);
-    ASSERT_TRUE(pKernel->isParentKernel);
-
-    const cl_queue_properties properties[3] = {(CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
-                                               0, 0};
-
-    DeviceQueue *devQueue = DeviceQueue::create(
-        &pCmdQ->getContext(),
-        pClDevice,
-        properties[0],
-        retVal);
-
-    SchedulerKernel &scheduler = pCmdQ->getContext().getSchedulerKernel();
-    // Aub execution takes huge time for bigger GWS
-    scheduler.setGws(24);
-
-    size_t offset[3] = {0, 0, 0};
-    size_t gws[3] = {1, 1, 1};
-    size_t lws[3] = {1, 1, 1};
-
-    // clang-format off
-    cl_image_format imageFormat;
-    imageFormat.image_channel_data_type = CL_UNSIGNED_INT8;
-    imageFormat.image_channel_order = CL_R;
-
-    cl_image_desc desc = { 0 };
-    desc.image_array_size = 0;
-    desc.image_depth = 1;
-    desc.image_height = 4;
-    desc.image_width = 4;
-    desc.image_type = CL_MEM_OBJECT_IMAGE3D;
-    desc.image_row_pitch = 0;
-    desc.image_slice_pitch = 0;
-    // clang-format on
-
-    auto memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(0, 0, 0, &pClDevice->getDevice());
-    auto surfaceFormat = Image::getSurfaceFormatFromTable(0, &imageFormat, context->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features);
-    Image *image = Image::create(
-        pContext,
-        memoryProperties,
-        0,
-        0,
-        surfaceFormat,
-        &desc,
-        nullptr,
-        retVal);
-
-    Buffer *buffer = BufferHelper<BufferUseHostPtr<>>::create(pContext);
-
-    cl_mem bufferMem = buffer;
-    cl_mem imageMem = image;
-
-    auto sampler = Sampler::create(
-        pContext,
-        CL_TRUE,
-        CL_ADDRESS_NONE,
-        CL_FILTER_LINEAR,
-        retVal);
-
-    uint64_t argScalar = 2;
-    pKernel->setArg(
-        3,
-        sizeof(uint64_t),
-        &argScalar);
-
-    pKernel->setArg(
-        2,
-        sizeof(cl_mem),
-        &bufferMem);
-
-    pKernel->setArg(
-        1,
-        sizeof(cl_mem),
-        &imageMem);
-
-    pKernel->setArg(
-        0,
-        sizeof(cl_sampler),
-        &sampler);
-
-    pCmdQ->enqueueKernel(pKernel, 1, offset, gws, lws, 0, 0, 0);
-
-    pCmdQ->finish();
-
-    uint32_t expectedNumberOfEnqueues = 1;
-    uint64_t gpuAddress = devQueue->getQueueBuffer()->getGpuAddress() + offsetof(IGIL_CommandQueue, m_controls.m_TotalNumberOfQueues);
-
-    AUBCommandStreamFixture::expectMemory<FamilyType>(reinterpret_cast<void *>(gpuAddress), &expectedNumberOfEnqueues, sizeof(uint32_t));
-    AUBCommandStreamFixture::expectMemory<FamilyType>(reinterpret_cast<void *>(buffer->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress()), &argScalar, sizeof(size_t));
-
-    delete devQueue;
-    delete image;
-    delete buffer;
-    delete sampler;
-}
diff --git a/opencl/test/unit_test/aub_tests/gen9/execution_model/CMakeLists.txt b/opencl/test/unit_test/aub_tests/gen9/execution_model/CMakeLists.txt
deleted file mode 100644
index 9a783f3d02..0000000000
--- a/opencl/test/unit_test/aub_tests/gen9/execution_model/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-#
-# Copyright (C) 2018-2021 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-target_sources(igdrcl_aub_tests PRIVATE
-               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-               ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_parent_kernel_tests_gen9.cpp
-)
diff --git a/opencl/test/unit_test/aub_tests/gen9/execution_model/enqueue_parent_kernel_tests_gen9.cpp b/opencl/test/unit_test/aub_tests/gen9/execution_model/enqueue_parent_kernel_tests_gen9.cpp
deleted file mode 100644
index 9fedfff85a..0000000000
--- a/opencl/test/unit_test/aub_tests/gen9/execution_model/enqueue_parent_kernel_tests_gen9.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2018-2021 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "shared/source/built_ins/built_ins.h"
-#include "shared/test/common/test_macros/test.h"
-
-#include "opencl/source/mem_obj/image.h"
-#include "opencl/source/sampler/sampler.h"
-#include "opencl/test/unit_test/aub_tests/fixtures/aub_parent_kernel_fixture.h"
-#include "opencl/test/unit_test/fixtures/buffer_fixture.h"
-#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
-
-using namespace NEO;
-
-GEN9TEST_F(AUBParentKernelFixture, WhenEnqueuingParentKernelThenExpectationsMet) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pClDevice);
-
-    ASSERT_NE(nullptr, pKernel);
-    ASSERT_TRUE(pKernel->isParentKernel);
-
-    const cl_queue_properties properties[3] = {(CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE),
-                                               0, 0};
-
-    DeviceQueue *devQueue = DeviceQueue::create(
-        &pCmdQ->getContext(),
-        pClDevice,
-        properties[0],
-        retVal);
-
-    SchedulerKernel &scheduler = pCmdQ->getContext().getSchedulerKernel();
-    // Aub execution takes huge time for bigger GWS
-    scheduler.setGws(24);
-
-    size_t offset[3] = {0, 0, 0};
-    size_t gws[3] = {1, 1, 1};
-    size_t lws[3] = {1, 1, 1};
-
-    // clang-format off
-    cl_image_format imageFormat;
-    imageFormat.image_channel_data_type = CL_UNSIGNED_INT8;
-    imageFormat.image_channel_order = CL_R;
-
-    cl_image_desc desc = { 0 };
-    desc.image_array_size = 0;
-    desc.image_depth = 1;
-    desc.image_height = 4;
-    desc.image_width = 4;
-    desc.image_type = CL_MEM_OBJECT_IMAGE3D;
-    desc.image_row_pitch = 0;
-    desc.image_slice_pitch = 0;
-    // clang-format on
-
-    auto memoryProperties = ClMemoryPropertiesHelper::createMemoryProperties(0, 0, 0, &context->getDevice(0)->getDevice());
-    auto surfaceFormat = Image::getSurfaceFormatFromTable(0, &imageFormat, context->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features);
-    Image *image = Image::create(
-        pContext,
-        memoryProperties,
-        0,
-        0,
-        surfaceFormat,
-        &desc,
-        nullptr,
-        retVal);
-
-    Buffer *buffer = BufferHelper<BufferUseHostPtr<>>::create(pContext);
-
-    cl_mem bufferMem = buffer;
-    cl_mem imageMem = image;
-
-    auto sampler = Sampler::create(
-        pContext,
-        CL_TRUE,
-        CL_ADDRESS_NONE,
-        CL_FILTER_LINEAR,
-        retVal);
-
-    uint64_t argScalar = 2;
-    pKernel->setArg(
-        3,
-        sizeof(uint64_t),
-        &argScalar);
-
-    pKernel->setArg(
-        2,
-        sizeof(cl_mem),
-        &bufferMem);
-
-    pKernel->setArg(
-        1,
-        sizeof(cl_mem),
-        &imageMem);
-
-    pKernel->setArg(
-        0,
-        sizeof(cl_sampler),
-        &sampler);
-
-    pCmdQ->enqueueKernel(pKernel, 1, offset, gws, lws, 0, 0, 0);
-
-    pCmdQ->finish();
-
-    uint32_t expectedNumberOfEnqueues = 1;
-    uint64_t gpuAddress = devQueue->getQueueBuffer()->getGpuAddress() + offsetof(IGIL_CommandQueue, m_controls.m_TotalNumberOfQueues);
-
-    AUBCommandStreamFixture::expectMemory<FamilyType>(reinterpret_cast<void *>(gpuAddress), &expectedNumberOfEnqueues, sizeof(uint32_t));
-    AUBCommandStreamFixture::expectMemory<FamilyType>(reinterpret_cast<void *>(buffer->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress()), &argScalar, sizeof(size_t));
-
-    delete devQueue;
-    delete image;
-    delete buffer;
-    delete sampler;
-}
diff --git a/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp b/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
index b570b6ebb6..0ee0e9b51a 100644
--- a/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
+++ b/opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
@@ -995,20 +995,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueKernelTest, givenCacheFlushAfterWalkerEnabled
     EXPECT_TRUE(pipeControl->getDcFlushEnable());
 }
 
-HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueAuxKernelTests, givenParentKernelButNoDeviceQueueWhenEnqueueIsCalledThenItReturnsInvalidOperation) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(pClDevice);
-
-    MyCmdQ<FamilyType> cmdQ(context, pClDevice);
-    size_t gws[3] = {1, 0, 0};
-
-    MockParentKernel::CreateParams createParams{};
-    std::unique_ptr<MockParentKernel> parentKernel(MockParentKernel::create(*context, createParams));
-    parentKernel->initialize();
-
-    auto status = cmdQ.enqueueKernel(parentKernel.get(), 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
-    EXPECT_EQ(CL_INVALID_OPERATION, status);
-}
-
 HWTEST_F(EnqueueKernelTest, givenTimestampWriteEnableWhenMarkerProfilingWithoutWaitListThenSizeHasFourMMIOStoresAndPipeControll) {
     pDevice->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = true;
     MockKernelWithInternals mockKernel(*pClDevice);
diff --git a/opencl/test/unit_test/context/context_tests.cpp b/opencl/test/unit_test/context/context_tests.cpp
index 119bdcfb4f..3f62e7fafe 100644
--- a/opencl/test/unit_test/context/context_tests.cpp
+++ b/opencl/test/unit_test/context/context_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -131,15 +131,6 @@ TEST_F(ContextTest, WhenSettingSpecialQueueThenQueueIsAvailable) {
     EXPECT_NE(specialQ, nullptr);
 }
 
-TEST_F(ContextTest, WhenSettingDefaultQueueThenQueueIsAvailable) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(context);
-    EXPECT_EQ(nullptr, context->getDefaultDeviceQueue());
-    auto dq = new DeviceQueue();
-    context->setDefaultDeviceQueue(dq);
-    EXPECT_EQ(dq, context->getDefaultDeviceQueue());
-    delete dq;
-}
-
 TEST_F(ContextTest, givenCmdQueueWithoutContextWhenBeingCreatedNextDeletedThenContextRefCountShouldNeitherBeIncrementedNorNextDecremented) {
     MockContext context((ClDevice *)devices[0]);
     EXPECT_EQ(1, context.getRefInternalCount());
@@ -157,25 +148,6 @@ TEST_F(ContextTest, givenCmdQueueWithoutContextWhenBeingCreatedNextDeletedThenCo
     EXPECT_EQ(1, context.getRefInternalCount());
 }
 
-TEST_F(ContextTest, givenDeviceQueueWithoutContextWhenBeingCreatedNextDeletedThenContextRefCountShouldNeitherBeIncrementedNorNextDecremented) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(context);
-    MockContext context((ClDevice *)devices[0]);
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    auto cmdQ1 = new DeviceQueue();
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    delete cmdQ1;
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    cl_queue_properties properties = 0;
-    auto cmdQ2 = new DeviceQueue(nullptr, (ClDevice *)devices[0], properties);
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    delete cmdQ2;
-    EXPECT_EQ(1, context.getRefInternalCount());
-}
-
 TEST_F(ContextTest, givenCmdQueueWithContextWhenBeingCreatedNextDeletedThenContextRefCountShouldBeIncrementedNextDecremented) {
     MockContext context((ClDevice *)devices[0]);
     EXPECT_EQ(1, context.getRefInternalCount());
@@ -187,33 +159,6 @@ TEST_F(ContextTest, givenCmdQueueWithContextWhenBeingCreatedNextDeletedThenConte
     EXPECT_EQ(1, context.getRefInternalCount());
 }
 
-TEST_F(ContextTest, givenDeviceCmdQueueWithContextWhenBeingCreatedNextDeletedThenContextRefCountShouldBeIncrementedNextDecremented) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(context);
-    MockContext context((ClDevice *)devices[0]);
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    cl_queue_properties properties = 0;
-    auto cmdQ = new DeviceQueue(&context, (ClDevice *)devices[0], properties);
-    EXPECT_EQ(2, context.getRefInternalCount());
-
-    delete cmdQ;
-    EXPECT_EQ(1, context.getRefInternalCount());
-}
-
-TEST_F(ContextTest, givenDefaultDeviceCmdQueueWithContextWhenBeingCreatedNextDeletedThenContextRefCountShouldBeIncrementedNextDecremented) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(context);
-    MockContext context((ClDevice *)devices[0]);
-    EXPECT_EQ(1, context.getRefInternalCount());
-
-    cl_queue_properties properties = 0;
-    auto cmdQ = new DeviceQueue(&context, (ClDevice *)devices[0], properties);
-    context.setDefaultDeviceQueue(cmdQ);
-    EXPECT_EQ(2, context.getRefInternalCount());
-
-    delete cmdQ;
-    EXPECT_EQ(1, context.getRefInternalCount());
-}
-
 TEST_F(ContextTest, givenContextWhenItIsCreatedFromDeviceThenItAddsRefCountToThisDevice) {
     auto device = castToObject<ClDevice>(devices[0]);
     EXPECT_EQ(2, device->getRefInternalCount());
diff --git a/opencl/test/unit_test/fixtures/CMakeLists.txt b/opencl/test/unit_test/fixtures/CMakeLists.txt
index 059c2acd4c..960782106f 100644
--- a/opencl/test/unit_test/fixtures/CMakeLists.txt
+++ b/opencl/test/unit_test/fixtures/CMakeLists.txt
@@ -20,7 +20,6 @@ set(IGDRCL_SRCS_tests_fixtures
     ${CMAKE_CURRENT_SOURCE_DIR}/device_instrumentation_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/enqueue_handler_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/execution_model_fixture.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/execution_model_kernel_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/hello_world_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/hello_world_kernel_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/image_fixture.cpp
diff --git a/opencl/test/unit_test/fixtures/execution_model_fixture.h b/opencl/test/unit_test/fixtures/execution_model_fixture.h
index cc9d2d6287..92751ad475 100644
--- a/opencl/test/unit_test/fixtures/execution_model_fixture.h
+++ b/opencl/test/unit_test/fixtures/execution_model_fixture.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,104 +11,10 @@
 
 #include "opencl/source/device_queue/device_queue.h"
 #include "opencl/test/unit_test/command_queue/command_queue_fixture.h"
-#include "opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_cl_device.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
 #include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
 
-class DeviceQueueFixture {
-  public:
-    void SetUp(Context *context, ClDevice *device) {
-        REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device);
-        cl_int errcodeRet = 0;
-        cl_queue_properties properties[3];
-
-        properties[0] = CL_QUEUE_PROPERTIES;
-        properties[1] = CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
-        properties[2] = 0;
-
-        ASSERT_NE(nullptr, context);
-        ASSERT_NE(nullptr, device);
-
-        pDevQueue = DeviceQueue::create(context, device,
-                                        properties[0],
-                                        errcodeRet);
-
-        ASSERT_NE(nullptr, pDevQueue);
-
-        auto devQueue = context->getDefaultDeviceQueue();
-
-        ASSERT_NE(nullptr, devQueue);
-        EXPECT_EQ(pDevQueue, devQueue);
-    }
-
-    void TearDown() {
-        delete pDevQueue;
-    }
-
-    DeviceQueue *pDevQueue = nullptr;
-};
-
-class ExecutionModelKernelTest : public ExecutionModelKernelFixture,
-                                 public CommandQueueHwFixture,
-                                 public DeviceQueueFixture,
-                                 public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
-  public:
-    void SetUp() override {
-        REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
-
-        DebugManager.flags.EnableTimestampPacket.set(0);
-        ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
-        CommandQueueHwFixture::SetUp(pClDevice, 0);
-        DeviceQueueFixture::SetUp(context, pClDevice);
-    }
-
-    void TearDown() override {
-        if (!IsSkipped()) {
-            DeviceQueueFixture::TearDown();
-            CommandQueueHwFixture::TearDown();
-            ExecutionModelKernelFixture::TearDown();
-        }
-    }
-
-    std::unique_ptr<KernelOperation> createBlockedCommandsData(CommandQueue &commandQueue) {
-        auto commandStream = new LinearStream();
-
-        auto &gpgpuCsr = commandQueue.getGpgpuCommandStreamReceiver();
-        gpgpuCsr.ensureCommandBufferAllocation(*commandStream, 1, 1);
-
-        return std::make_unique<KernelOperation>(commandStream, *gpgpuCsr.getInternalAllocationStorage());
-    }
-
-    DebugManagerStateRestore dbgRestore;
-};
-
-class ExecutionModelSchedulerTest : public ClDeviceFixture,
-                                    public CommandQueueHwFixture,
-                                    public DeviceQueueFixture {
-  public:
-    void SetUp() override {
-        ClDeviceFixture::SetUp();
-        CommandQueueHwFixture::SetUp(pClDevice, 0);
-        DeviceQueueFixture::SetUp(context, pClDevice);
-
-        parentKernel = MockParentKernel::create(*context);
-        ASSERT_NE(nullptr, parentKernel);
-        kernelInfos = MockKernel::toKernelInfoContainer(parentKernel->getKernelInfo(), rootDeviceIndex);
-        pMultiDeviceKernel = new MockMultiDeviceKernel(MockMultiDeviceKernel::toKernelVector(parentKernel), kernelInfos);
-    }
-
-    void TearDown() override {
-        pMultiDeviceKernel->release();
-
-        DeviceQueueFixture::TearDown();
-        CommandQueueHwFixture::TearDown();
-        ClDeviceFixture::TearDown();
-    }
-    KernelInfoContainer kernelInfos;
-    MockMultiDeviceKernel *pMultiDeviceKernel = nullptr;
-    MockParentKernel *parentKernel = nullptr;
-};
-
 struct ParentKernelCommandQueueFixture : public CommandQueueHwFixture,
                                          testing::Test {
 
diff --git a/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h b/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
deleted file mode 100644
index 397677b635..0000000000
--- a/opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2018-2021 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "shared/test/common/test_macros/test.h"
-
-#include "opencl/source/kernel/kernel.h"
-#include "opencl/test/unit_test/fixtures/platform_fixture.h"
-#include "opencl/test/unit_test/mocks/mock_kernel.h"
-#include "opencl/test/unit_test/program/program_from_binary.h"
-#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
-
-using namespace NEO;
-
-struct ExecutionModelKernelFixture : public ProgramFromBinaryFixture,
-                                     public PlatformFixture {
-    using ProgramFromBinaryFixture::SetUp;
-    void SetUp(const char *binaryFileName, const char *kernelName) {
-        REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
-
-        PlatformFixture::SetUp();
-
-        std::string options("-cl-std=CL2.0");
-        this->setOptions(options);
-        ProgramFromBinaryFixture::SetUp(binaryFileName, kernelName);
-
-        ASSERT_NE(nullptr, pProgram);
-        ASSERT_EQ(CL_SUCCESS, retVal);
-
-        retVal = pProgram->build(
-            pProgram->getDevices(),
-            nullptr,
-            false);
-        ASSERT_EQ(CL_SUCCESS, retVal);
-
-        pMultiDeviceKernel = MultiDeviceKernel::create<MockKernel>(pProgram,
-                                                                   pProgram->getKernelInfosForKernel(kernelName),
-                                                                   &retVal);
-        pKernel = pMultiDeviceKernel->getKernel(rootDeviceIndex);
-
-        ASSERT_EQ(CL_SUCCESS, retVal);
-        ASSERT_NE(nullptr, pKernel);
-    }
-
-    void TearDown() override {
-        if (IsSkipped()) {
-            return;
-        }
-        if (pMultiDeviceKernel != nullptr) {
-            pMultiDeviceKernel->release();
-        }
-
-        ProgramFromBinaryFixture::TearDown();
-        PlatformFixture::TearDown();
-
-        if (pDevice != nullptr) {
-            delete pDevice;
-            pDevice = nullptr;
-        }
-        if (pClDevice != nullptr) {
-            delete pClDevice;
-            pClDevice = nullptr;
-        }
-    }
-
-    MultiDeviceKernel *pMultiDeviceKernel = nullptr;
-    Kernel *pKernel = nullptr;
-    cl_int retVal = CL_SUCCESS;
-};
diff --git a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
index 29b64b5dda..f0e816372f 100644
--- a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
+++ b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
@@ -16,13 +16,13 @@
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
 #include "shared/test/common/mocks/mock_allocation_properties.h"
 #include "shared/test/common/mocks/mock_graphics_allocation.h"
+#include "shared/test/common/test_macros/test_checks_shared.h"
 #include "shared/test/unit_test/utilities/base_object_utils.h"
 
 #include "opencl/source/api/api.h"
 #include "opencl/source/built_ins/builtins_dispatch_builder.h"
 #include "opencl/source/command_queue/command_queue_hw.h"
 #include "opencl/source/helpers/hardware_commands_helper.h"
-#include "opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h"
 #include "opencl/test/unit_test/fixtures/hello_world_fixture.h"
 #include "opencl/test/unit_test/fixtures/image_fixture.h"
 
@@ -1003,59 +1003,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, GivenKernelWithSamplersWhenInd
     delete[] mockDsh;
 }
 
-struct ParentKernelCommandsFromBinaryTest : public ExecutionModelKernelFixture,
-                                            public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
-
-    void SetUp() override {
-
-        ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
-    }
-};
-HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelCommandsFromBinaryTest, WhenGettingSizeRequiredForExecutionModelForSurfaceStatesThenReturnSizeOfBlocksPlusMaxBindingTableSizeForAllIdtEntriesAndSchedulerSshSize) {
-    using BINDING_TABLE_STATE = typename FamilyType::BINDING_TABLE_STATE;
-
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
-
-    EXPECT_TRUE(pKernel->isParentKernel);
-
-    size_t totalSize = 0;
-
-    BlockKernelManager *blockManager = pKernel->getProgram()->getBlockKernelManager();
-    uint32_t blockCount = static_cast<uint32_t>(blockManager->getCount());
-
-    totalSize = BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE - 1; // for initial alignment
-
-    uint32_t maxBindingTableCount = 0;
-
-    for (uint32_t i = 0; i < blockCount; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-
-        totalSize += pBlockInfo->heapInfo.SurfaceStateHeapSize;
-        totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
-
-        maxBindingTableCount = std::max(maxBindingTableCount, static_cast<uint32_t>(pBlockInfo->kernelDescriptor.payloadMappings.bindingTable.numEntries));
-    }
-
-    totalSize += maxBindingTableCount * sizeof(BINDING_TABLE_STATE) * DeviceQueue::interfaceDescriptorEntries;
-
-    auto &scheduler = pContext->getSchedulerKernel();
-    auto schedulerSshSize = scheduler.getSurfaceStateHeapSize();
-    totalSize += schedulerSshSize + ((schedulerSshSize != 0) ? BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE : 0);
-
-    totalSize = alignUp(totalSize, BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
-
-    EXPECT_EQ(totalSize, HardwareCommandsHelper<FamilyType>::getSshSizeForExecutionModel(*pKernel));
-}
-
-static const char *binaryFile = "simple_block_kernel";
-static const char *KernelNames[] = {"kernel_reflection", "simple_block_kernel"};
-
-INSTANTIATE_TEST_CASE_P(ParentKernelCommandsFromBinaryTest,
-                        ParentKernelCommandsFromBinaryTest,
-                        ::testing::Combine(
-                            ::testing::Values(binaryFile),
-                            ::testing::ValuesIn(KernelNames)));
-
 HWTEST_F(HardwareCommandsTest, givenEnabledPassInlineDataWhenKernelAllowsInlineThenReturnTrue) {
     DebugManagerStateRestore restore;
     DebugManager.flags.EnablePassInlineData.set(1u);
diff --git a/opencl/test/unit_test/kernel/debug_kernel_tests.cpp b/opencl/test/unit_test/kernel/debug_kernel_tests.cpp
index 8c5f0dd10b..e6a357a6c0 100644
--- a/opencl/test/unit_test/kernel/debug_kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/debug_kernel_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2021 Intel Corporation
+ * Copyright (C) 2018-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,7 +8,7 @@
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/test_macros/test.h"
 
-#include "opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_cl_device.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
 #include "opencl/test/unit_test/mocks/mock_program.h"
 
diff --git a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp b/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
index 20d210ae19..99fd368685 100644
--- a/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_reflection_surface_tests.cpp
@@ -14,9 +14,9 @@
 #include "opencl/source/program/printf_handler.h"
 #include "opencl/source/sampler/sampler.h"
 #include "opencl/test/unit_test/fixtures/execution_model_fixture.h"
-#include "opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h"
 #include "opencl/test/unit_test/fixtures/image_fixture.h"
 #include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
+#include "opencl/test/unit_test/fixtures/platform_fixture.h"
 #include "opencl/test/unit_test/helpers/gtest_helpers.h"
 #include "opencl/test/unit_test/mocks/mock_context.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
@@ -32,485 +32,6 @@
 
 using namespace NEO;
 
-struct KernelReflectionSurfaceTest : public ExecutionModelKernelFixture,
-                                     public ::testing::WithParamInterface<std::tuple<const char *, const char *>> {
-
-    void SetUp() override {
-
-        ExecutionModelKernelFixture::SetUp(std::get<0>(GetParam()), std::get<1>(GetParam()));
-    }
-};
-typedef ExecutionModelKernelTest KernelReflectionSurfaceWithQueueTest;
-
-TEST_P(KernelReflectionSurfaceTest, WhenCreatingKernelThenKernelReflectionSurfaceIsNull) {
-    EXPECT_EQ(nullptr, pKernel->getKernelReflectionSurface());
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenEmptyKernelInfoWhenPassedToGetCurbeParamsThenEmptyVectorIsReturned) {
-    MockKernelInfo info;
-
-    info.addArgImage(0, 32);
-    info.addArgSampler(1, 32);
-    info.addArgImmediate(2, 4, 32);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParamsForBlock, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    // 3 params with Binding Table index of type 1024
-    EXPECT_EQ(3u, curbeParamsForBlock.size());
-    for (const auto &curbeParam : curbeParamsForBlock) {
-        EXPECT_EQ(1024u, curbeParam.m_parameterType);
-    }
-    EXPECT_EQ(0u, firstSSHTokenIndex);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithCorrectlyFilledImageArgumentWhenPassedToGetCurbeParamsThenImageCurbeParamsAreReturned) {
-    MockKernelInfo info;
-
-    const uint32_t offsetDataType = 4;
-    const uint32_t offsetChannelOrder = 8;
-    const uint32_t offsetHeap = 12;
-    const uint32_t offsetDepth = 16;
-    const uint32_t offsetWidth = 20;
-    const uint32_t offsetHeight = 24;
-    const uint32_t offsetObjectID = 28;
-    const uint32_t offsetArraySize = 32;
-
-    info.addArgImage(0, offsetHeap);
-    auto &metaPayload = info.argAsImg(0).metadataPayload;
-    metaPayload.channelDataType = offsetDataType;
-    metaPayload.channelOrder = offsetChannelOrder;
-    metaPayload.imgDepth = offsetDepth;
-    metaPayload.imgWidth = offsetWidth;
-    metaPayload.imgHeight = offsetHeight;
-    metaPayload.arraySize = offsetArraySize;
-
-    info.addExtendedDeviceSideEnqueueDescriptor(0, offsetObjectID);
-    info.setAccessQualifier(0, KernelArgMetadata::AccessReadOnly);
-    info.addExtendedMetadata(0, "img", "", "read_only");
-
-    info.kernelDescriptor.kernelAttributes.gpuPointerSize = 8;
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    std::vector<uint32_t> supportedImageParamTypes = {iOpenCL::DATA_PARAMETER_IMAGE_WIDTH,
-                                                      iOpenCL::DATA_PARAMETER_IMAGE_HEIGHT,
-                                                      iOpenCL::DATA_PARAMETER_IMAGE_DEPTH,
-                                                      iOpenCL::DATA_PARAMETER_IMAGE_CHANNEL_DATA_TYPE,
-                                                      iOpenCL::DATA_PARAMETER_IMAGE_CHANNEL_ORDER,
-                                                      iOpenCL::DATA_PARAMETER_IMAGE_ARRAY_SIZE,
-                                                      iOpenCL::DATA_PARAMETER_OBJECT_ID,
-                                                      1024}; // type for Binding Table Index
-
-    std::sort(supportedImageParamTypes.begin(), supportedImageParamTypes.end());
-
-    size_t ParamCount = supportedImageParamTypes.size();
-
-    EXPECT_EQ(ParamCount, curbeParams.size());
-
-    for (size_t i = 0; i < std::min(ParamCount, curbeParams.size()); i++) {
-        if (i < ParamCount - 1) {
-            EXPECT_EQ(supportedImageParamTypes[i] + 50, curbeParams[i].m_parameterType);
-            EXPECT_EQ(sizeof(uint32_t), curbeParams[i].m_parameterSize);
-        } else {
-            EXPECT_EQ(1024u, curbeParams[i].m_parameterType);
-            EXPECT_EQ(8u, curbeParams[i].m_parameterSize);
-        }
-
-        switch (curbeParams[i].m_parameterType - 50) {
-        case iOpenCL::DATA_PARAMETER_IMAGE_WIDTH:
-            EXPECT_EQ(offsetWidth, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_IMAGE_HEIGHT:
-            EXPECT_EQ(offsetHeight, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_IMAGE_DEPTH:
-            EXPECT_EQ(offsetDepth, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_IMAGE_CHANNEL_DATA_TYPE:
-            EXPECT_EQ(offsetDataType, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_IMAGE_CHANNEL_ORDER:
-            EXPECT_EQ(offsetChannelOrder, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_IMAGE_ARRAY_SIZE:
-            EXPECT_EQ(offsetArraySize, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_OBJECT_ID:
-            EXPECT_EQ(offsetObjectID, curbeParams[i].m_patchOffset);
-            break;
-        }
-    }
-    EXPECT_EQ(curbeParams.size() - 1, firstSSHTokenIndex);
-}
-
-HWTEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithSetBindingTableStateAndImageArgumentWhenPassedToGetCurbeParamsThenProperCurbeParamIsReturned) {
-    typedef typename FamilyType::BINDING_TABLE_STATE BINDING_TABLE_STATE;
-
-    MockKernelInfo info;
-    uint32_t imageOffset = 32;
-    uint32_t btIndex = 3;
-
-    info.kernelDescriptor.kernelAttributes.gpuPointerSize = 8;
-
-    info.addArgImage(0, imageOffset, iOpenCL::IMAGE_MEMORY_OBJECT_2D);
-
-    info.setBindingTable(0, 4);
-
-    BINDING_TABLE_STATE bindingTableState[4];
-
-    memset(&bindingTableState, 0, 4 * sizeof(BINDING_TABLE_STATE));
-
-    bindingTableState[btIndex].getRawData(0) = imageOffset;
-
-    info.heapInfo.pSsh = reinterpret_cast<void *>(bindingTableState);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    EXPECT_NE(0u, curbeParams.size());
-    bool foundProperParam = false;
-
-    for (const auto &curbeParam : curbeParams) {
-        if (curbeParam.m_parameterType == 1024u) {
-            EXPECT_EQ(btIndex, curbeParam.m_patchOffset);
-            EXPECT_EQ(8u, curbeParam.m_parameterSize);
-            EXPECT_EQ(0u, curbeParam.m_sourceOffset);
-            foundProperParam = true;
-            break;
-        }
-    }
-    EXPECT_TRUE(foundProperParam);
-}
-
-HWTEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithBindingTableStateAndImageArgumentWhenCountIsZeroThenGetCurbeParamsReturnsMaxBTIndex) {
-    typedef typename FamilyType::BINDING_TABLE_STATE BINDING_TABLE_STATE;
-
-    MockKernelInfo info;
-    uint32_t imageOffset = 32;
-    uint32_t btIndex = 0;
-    uint32_t maxBTIndex = 253;
-
-    info.kernelDescriptor.kernelAttributes.gpuPointerSize = 8;
-
-    info.addArgImage(0, imageOffset, iOpenCL::IMAGE_MEMORY_OBJECT_2D);
-
-    info.setBindingTable(0, 0);
-
-    BINDING_TABLE_STATE bindingTableState[1];
-
-    memset(&bindingTableState, 0, 1 * sizeof(BINDING_TABLE_STATE));
-
-    bindingTableState[btIndex].getRawData(0) = imageOffset;
-
-    info.heapInfo.pSsh = reinterpret_cast<void *>(bindingTableState);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    EXPECT_EQ(1u, curbeParams.size());
-    bool foundProperParam = false;
-
-    for (const auto &curbeParam : curbeParams) {
-        if (curbeParam.m_parameterType == 1024u) {
-            EXPECT_EQ(maxBTIndex, curbeParam.m_patchOffset);
-            EXPECT_EQ(8u, curbeParam.m_parameterSize);
-            EXPECT_EQ(0u, curbeParam.m_sourceOffset);
-            foundProperParam = true;
-            break;
-        }
-    }
-    EXPECT_TRUE(foundProperParam);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithCorrectlyFilledSamplerArgumentWhenPassedToGetCurbeParamsThenSamplerCurbeParamsAreReturned) {
-
-    MockKernelInfo info;
-    SPatchSamplerKernelArgument samplerMemObjKernelArg;
-    samplerMemObjKernelArg.ArgumentNumber = 1;
-    samplerMemObjKernelArg.Offset = 32;
-    samplerMemObjKernelArg.Size = 4;
-    samplerMemObjKernelArg.Type = iOpenCL::SAMPLER_OBJECT_TEXTURE;
-
-    const uint32_t offsetSamplerAddressingMode = 4;
-    const uint32_t offsetSamplerNormalizedCoords = 8;
-    const uint32_t offsetSamplerSnapWa = 12;
-    const uint32_t offsetObjectID = 28;
-
-    info.addArgSampler(1, 32, offsetSamplerAddressingMode, offsetSamplerNormalizedCoords, offsetSamplerSnapWa);
-    info.addExtendedMetadata(1, "smp");
-    info.addExtendedDeviceSideEnqueueDescriptor(1, offsetObjectID);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    std::vector<uint32_t> supportedSamplerParamTypes = {iOpenCL::DATA_PARAMETER_SAMPLER_ADDRESS_MODE,
-                                                        iOpenCL::DATA_PARAMETER_SAMPLER_NORMALIZED_COORDS,
-                                                        iOpenCL::DATA_PARAMETER_SAMPLER_COORDINATE_SNAP_WA_REQUIRED,
-                                                        iOpenCL::DATA_PARAMETER_OBJECT_ID};
-
-    std::sort(supportedSamplerParamTypes.begin(), supportedSamplerParamTypes.end());
-
-    size_t ParamCount = supportedSamplerParamTypes.size();
-
-    EXPECT_EQ(ParamCount + 2, curbeParams.size()); // + 2 for 2 arguments' Binding Table Index params stored
-
-    for (size_t i = 0; i < std::min(ParamCount, curbeParams.size()); i++) {
-        EXPECT_EQ(supportedSamplerParamTypes[i] + 100, curbeParams[i].m_parameterType);
-
-        EXPECT_EQ(sizeof(uint32_t), curbeParams[i].m_parameterSize);
-
-        switch (curbeParams[i].m_parameterType - 100) {
-        case iOpenCL::DATA_PARAMETER_SAMPLER_ADDRESS_MODE:
-            EXPECT_EQ(offsetSamplerAddressingMode, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_SAMPLER_NORMALIZED_COORDS:
-            EXPECT_EQ(offsetSamplerNormalizedCoords, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_SAMPLER_COORDINATE_SNAP_WA_REQUIRED:
-            EXPECT_EQ(offsetSamplerSnapWa, curbeParams[i].m_patchOffset);
-            break;
-        case iOpenCL::DATA_PARAMETER_OBJECT_ID:
-            EXPECT_EQ(offsetObjectID, curbeParams[i].m_patchOffset);
-            break;
-        }
-    }
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithBufferAndDataParameterBuffersTokensWhenPassedToGetCurbeParamsThenCorrectCurbeParamsWithProperSizesAreReturned) {
-
-    MockKernelInfo info;
-    info.addArgImmediate(0, 8, 40, 0, true);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    EXPECT_LT(1u, curbeParams.size());
-    bool kernelArgumentTokenFound = false;
-    bool kernelArgumentSSHParamFound = false;
-    for (const auto &curbeParam : curbeParams) {
-
-        if (iOpenCL::DATA_PARAMETER_KERNEL_ARGUMENT == curbeParam.m_parameterType) {
-            kernelArgumentTokenFound = true;
-            EXPECT_EQ(0u, curbeParam.m_sourceOffset);
-            EXPECT_EQ(8u, curbeParam.m_parameterSize);
-            EXPECT_EQ(40u, curbeParam.m_patchOffset);
-        }
-        // kernel arg SSH param
-        if (1024 == curbeParam.m_parameterType) {
-            kernelArgumentSSHParamFound = true;
-            EXPECT_EQ(0u, curbeParam.m_sourceOffset);
-            EXPECT_EQ(0u, curbeParam.m_parameterSize);
-            EXPECT_EQ(0u, curbeParam.m_patchOffset);
-        }
-    }
-    EXPECT_TRUE(kernelArgumentTokenFound);
-    EXPECT_TRUE((tokenMask & ((uint64_t)1 << iOpenCL::DATA_PARAMETER_KERNEL_ARGUMENT)) > 0);
-
-    EXPECT_TRUE(kernelArgumentSSHParamFound);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithBufferAndNoDataParameterBuffersTokenWhenPassedToGetCurbeParamsThenCurbeParamForDataKernelArgumentTokenIsNotReturned) {
-    MockKernelInfo info;
-    info.addArgImmediate(0, 8, 40);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    bool kernelArgumentTokenFound = false;
-    for (const auto &curbeParam : curbeParams) {
-        if (iOpenCL::DATA_PARAMETER_KERNEL_ARGUMENT == curbeParam.m_parameterType) {
-            kernelArgumentTokenFound = true;
-        }
-    }
-    EXPECT_FALSE(kernelArgumentTokenFound);
-    EXPECT_TRUE((tokenMask & ((uint64_t)1 << iOpenCL::DATA_PARAMETER_KERNEL_ARGUMENT)) == 0);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithLocalMemoryParameterWhenPassedToGetCurbeParamsThenCurbeParamForLocalMemoryArgIsReturned) {
-    MockKernelInfo info;
-
-    const uint32_t crossThreadOffset = 10;
-    const uint32_t slmAlignment = 80;
-
-    info.addArgLocal(0, crossThreadOffset, slmAlignment);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    bool localMemoryTokenFound = false;
-    for (const auto &curbeParam : curbeParams) {
-        if (iOpenCL::DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES == curbeParam.m_parameterType) {
-            localMemoryTokenFound = true;
-            EXPECT_EQ(slmAlignment, curbeParam.m_sourceOffset);
-            EXPECT_EQ(0u, curbeParam.m_parameterSize);
-            EXPECT_EQ(crossThreadOffset, curbeParam.m_patchOffset);
-        }
-    }
-    EXPECT_TRUE(localMemoryTokenFound);
-    EXPECT_TRUE((tokenMask & ((uint64_t)1 << iOpenCL::DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES)) > 0);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithoutLocalMemoryParameterWhenPassedToGetCurbeParamsThenCurbeParamForLocalMemoryArgIsNotReturned) {
-
-    MockKernelInfo info;
-
-    const uint32_t crossThreadOffset = 10;
-    const uint32_t slmAlignment = 0;
-
-    info.addArgLocal(0, crossThreadOffset, slmAlignment);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    bool localMemoryTokenFound = false;
-    for (const auto &curbeParam : curbeParams) {
-        if (iOpenCL::DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES == curbeParam.m_parameterType) {
-            localMemoryTokenFound = true;
-        }
-    }
-    EXPECT_FALSE(localMemoryTokenFound);
-    EXPECT_TRUE((tokenMask & ((uint64_t)1 << iOpenCL::DATA_PARAMETER_SUM_OF_LOCAL_MEMORY_OBJECT_ARGUMENT_SIZES)) == 0);
-}
-
-TEST_P(KernelReflectionSurfaceTest, WhenGettingCurbeParamsThenReturnedVectorIsSortedIncreasing) {
-    EXPECT_TRUE(pKernel->isParentKernel);
-
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_NE(0u, blockCount);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    for (size_t i = 0; i < blockCount; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-        uint64_t tokenMask = 0;
-        uint32_t firstSSHTokenIndex = 0;
-        MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParamsForBlock, tokenMask, firstSSHTokenIndex, *pBlockInfo, pDevice->getHardwareInfo());
-
-        if (pBlockInfo->kernelDescriptor.kernelMetadata.kernelName.find("simple_block_kernel") == std::string::npos) {
-            EXPECT_LT(1u, curbeParamsForBlock.size());
-        }
-
-        for (size_t i = 1; i < curbeParamsForBlock.size(); i++) {
-            EXPECT_LE(curbeParamsForBlock[i - 1].m_parameterType, curbeParamsForBlock[i].m_parameterType);
-            if (curbeParamsForBlock[i - 1].m_parameterType == curbeParamsForBlock[i].m_parameterType) {
-
-                if (curbeParamsForBlock[i - 1].m_parameterType == iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_LOCAL_WORK_SIZE) {
-                    EXPECT_LE(curbeParamsForBlock[i - 1].m_patchOffset, curbeParamsForBlock[i].m_patchOffset);
-                } else {
-                    EXPECT_LE(curbeParamsForBlock[i - 1].m_sourceOffset, curbeParamsForBlock[i].m_sourceOffset);
-                }
-            }
-        }
-        EXPECT_EQ(curbeParamsForBlock.size() - pBlockInfo->getExplicitArgs().size(), firstSSHTokenIndex);
-        curbeParamsForBlock.resize(0);
-    }
-}
-
-TEST_P(KernelReflectionSurfaceTest, WhenGettingCurbeParamsThenReturnedVectorHasExpectedParamTypes) {
-    EXPECT_TRUE(pKernel->isParentKernel);
-
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_NE(0u, blockCount);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    for (size_t i = 0; i < blockCount; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-        uint64_t tokenMask = 0;
-        uint32_t firstSSHTokenIndex = 0;
-        MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParamsForBlock, tokenMask, firstSSHTokenIndex, *pBlockInfo, pDevice->getHardwareInfo());
-
-        const uint32_t bufferType = 49;
-        const uint32_t imageType = iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_OBJECT_ID + 50;
-        const uint32_t samplerType = iOpenCL::DATA_PARAMETER_TOKEN::DATA_PARAMETER_OBJECT_ID + 100;
-
-        bool bufferFound = false;
-        bool imageFound = false;
-        bool samplerFound = false;
-
-        if (pBlockInfo->kernelDescriptor.kernelMetadata.kernelName.find("kernel_reflection_dispatch_0") != std::string::npos) {
-            EXPECT_LT(1u, curbeParamsForBlock.size());
-
-            for (const auto &curbeParams : curbeParamsForBlock) {
-
-                switch (curbeParams.m_parameterType) {
-                case bufferType:
-                    bufferFound = true;
-                    break;
-                case imageType:
-                    imageFound = true;
-                    break;
-                case samplerType:
-                    samplerFound = true;
-                    break;
-                }
-            }
-
-            EXPECT_TRUE(bufferFound);
-            EXPECT_TRUE(imageFound);
-            EXPECT_TRUE(samplerFound);
-        }
-        EXPECT_EQ(curbeParamsForBlock.size() - pBlockInfo->getExplicitArgs().size(), firstSSHTokenIndex);
-        curbeParamsForBlock.resize(0);
-    }
-}
-
-TEST_P(KernelReflectionSurfaceTest, WhenGettingCurbeParamsThenTokenMaskIsCorrect) {
-    EXPECT_TRUE(pKernel->isParentKernel);
-
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_NE(0u, blockCount);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    for (size_t i = 0; i < blockCount; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-
-        uint64_t tokenMask = 0;
-        uint32_t firstSSHTokenIndex = 0;
-        MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParamsForBlock, tokenMask, firstSSHTokenIndex, *pBlockInfo, pDevice->getHardwareInfo());
-
-        if (pBlockInfo->kernelDescriptor.kernelMetadata.kernelName.find("kernel_reflection_dispatch_0") != std::string::npos) {
-            EXPECT_LT(1u, curbeParamsForBlock.size());
-
-            const uint64_t bufferToken = (uint64_t)1 << 63;
-            const uint64_t imageToken = (uint64_t)1 << 50;
-            const uint64_t samplerToken = (uint64_t)1 << 51;
-
-            uint64_t expectedTokens = bufferToken | imageToken | samplerToken;
-            EXPECT_NE(0u, tokenMask & expectedTokens);
-        }
-
-        curbeParamsForBlock.resize(0);
-    }
-}
-
 TEST(KernelReflectionSurfaceTestSingle, GivenNonParentKernelWhenCreatingKernelReflectionSurfaceThenKernelReflectionSurfaceIsNotCreated) {
     MockClDevice device{new MockDevice};
     MockProgram program(toClDeviceVector(device));
@@ -526,494 +47,6 @@ TEST(KernelReflectionSurfaceTestSingle, GivenNonParentKernelWhenCreatingKernelRe
     EXPECT_EQ(nullptr, reflectionSurface);
 }
 
-TEST(KernelReflectionSurfaceTestSingle, GivenNoKernelArgsWhenObtainingKernelReflectionSurfaceThenParamsAreCorrect) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
-    MockContext context;
-    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
-    MockProgram program(toClDeviceVector(*device));
-    MockKernelInfo *blockInfo = new MockKernelInfo;
-    MockKernelInfo &info = *blockInfo;
-    cl_queue_properties properties[1] = {0};
-    DeviceQueue devQueue(&context, device.get(), properties[0]);
-
-    info.kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
-    info.setCrossThreadDataSize(0);
-    info.setBindingTable(0, 0);
-
-    MockKernel kernel(&program, info, *device);
-
-    EXPECT_TRUE(kernel.isParentKernel);
-
-    program.blockKernelManager->addBlockKernelInfo(blockInfo);
-
-    kernel.createReflectionSurface();
-    auto reflectionSurface = kernel.getKernelReflectionSurface();
-    EXPECT_NE(nullptr, reflectionSurface);
-
-    kernel.patchReflectionSurface<true>(&devQueue, nullptr);
-
-    uint64_t undefinedOffset = MockKernel::ReflectionSurfaceHelperPublic::undefinedOffset;
-
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::devQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::eventPool.offset);
-
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::devQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::eventPool.size);
-}
-
-TEST(KernelReflectionSurfaceTestSingle, GivenDeviceQueueKernelArgWhenObtainingKernelReflectionSurfaceThenParamsAreCorrect) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(defaultHwInfo);
-    MockContext context;
-    auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
-    MockProgram program(toClDeviceVector(*device));
-
-    MockKernelInfo *blockInfo = new MockKernelInfo;
-    MockKernelInfo &info = *blockInfo;
-    cl_queue_properties properties[1] = {0};
-    DeviceQueue devQueue(&context, device.get(), properties[0]);
-
-    uint32_t devQueueCurbeOffset = 16;
-    uint32_t devQueueCurbeSize = 4;
-
-    info.kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
-    info.setCrossThreadDataSize(0);
-    info.setBindingTable(0, 0);
-    info.addArgDevQueue(0, devQueueCurbeOffset, devQueueCurbeSize);
-
-    MockKernel kernel(&program, info, *device);
-
-    EXPECT_TRUE(kernel.isParentKernel);
-
-    program.blockKernelManager->addBlockKernelInfo(blockInfo);
-
-    kernel.createReflectionSurface();
-    auto reflectionSurface = kernel.getKernelReflectionSurface();
-    EXPECT_NE(nullptr, reflectionSurface);
-
-    kernel.patchReflectionSurface<true>(&devQueue, nullptr);
-    uint64_t undefinedOffset = MockKernel::ReflectionSurfaceHelperPublic::undefinedOffset;
-
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.offset);
-    EXPECT_EQ(devQueueCurbeOffset, MockKernel::ReflectionSurfaceHelperPublic::devQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::eventPool.offset);
-
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.size);
-    EXPECT_EQ(4u, MockKernel::ReflectionSurfaceHelperPublic::devQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::eventPool.size);
-}
-
-TEST_P(KernelReflectionSurfaceTest, WhenCreatingKernelReflectionSurfaceThenKernelReflectionSurfaceIsCorrect) {
-    EXPECT_TRUE(pKernel->isParentKernel);
-
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_EQ(3u, blockCount);
-
-    size_t maxConstantBufferSize = 0;
-    size_t parentImageCount = 0;
-    size_t parentSamplerCount = 0;
-
-    if (pKernel->getKernelInfo().kernelDescriptor.kernelMetadata.kernelName == "kernel_reflection") {
-        parentImageCount = 1;
-        parentSamplerCount = 1;
-    }
-
-    size_t samplerStateArrayAndBorderColorTotalSize = 0;
-    size_t totalCurbeParamsSize = 0;
-
-    std::vector<size_t> blockCurbeParamCounts(blockCount);
-    std::vector<size_t> samplerStateAndBorderColorSizes(blockCount);
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    for (size_t i = 0; i < blockCount; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-        uint64_t tokenMask = 0;
-        uint32_t firstSSHTokenIndex = 0;
-        MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParamsForBlock, tokenMask, firstSSHTokenIndex, *pBlockInfo, pDevice->getHardwareInfo());
-
-        blockCurbeParamCounts[i] = curbeParamsForBlock.size();
-
-        maxConstantBufferSize = std::max(maxConstantBufferSize, static_cast<size_t>(pBlockInfo->kernelDescriptor.kernelAttributes.crossThreadDataSize));
-        totalCurbeParamsSize += blockCurbeParamCounts[i];
-
-        size_t samplerStateAndBorderColorSize = pBlockInfo->getSamplerStateArraySize(pDevice->getHardwareInfo());
-        samplerStateAndBorderColorSize = alignUp(samplerStateAndBorderColorSize, Sampler::samplerStateArrayAlignment);
-        samplerStateAndBorderColorSize += pBlockInfo->getBorderColorStateSize();
-        samplerStateAndBorderColorSizes[i] = samplerStateAndBorderColorSize;
-
-        samplerStateArrayAndBorderColorTotalSize += alignUp(samplerStateAndBorderColorSizes[i], sizeof(void *));
-        curbeParamsForBlock.clear();
-    }
-
-    totalCurbeParamsSize *= sizeof(IGIL_KernelCurbeParams);
-
-    size_t expectedReflectionSurfaceSize = alignUp(sizeof(IGIL_KernelDataHeader) + sizeof(IGIL_KernelAddressData) * blockCount, sizeof(void *));
-    expectedReflectionSurfaceSize += alignUp(sizeof(IGIL_KernelData), sizeof(void *)) * blockCount;
-    expectedReflectionSurfaceSize += (parentSamplerCount * sizeof(IGIL_SamplerParams) + maxConstantBufferSize) * blockCount +
-                                     totalCurbeParamsSize +
-                                     parentImageCount * sizeof(IGIL_ImageParamters) +
-                                     parentSamplerCount * sizeof(IGIL_ParentSamplerParams) +
-                                     samplerStateArrayAndBorderColorTotalSize;
-
-    pKernel->createReflectionSurface();
-    auto reflectionSurface = pKernel->getKernelReflectionSurface();
-
-    ASSERT_NE(nullptr, reflectionSurface);
-    EXPECT_EQ(expectedReflectionSurfaceSize, reflectionSurface->getUnderlyingBufferSize());
-
-    IGIL_KernelDataHeader *pKernelHeader = reinterpret_cast<IGIL_KernelDataHeader *>(reflectionSurface->getUnderlyingBuffer());
-
-    uint32_t parentImages = 0;
-    uint32_t parentSamplers = 0;
-
-    if (pKernel->getKernelInfo().kernelDescriptor.kernelMetadata.kernelName == "kernel_reflection") {
-        parentImages = 1;
-        parentSamplers = 1;
-        EXPECT_LT(sizeof(IGIL_KernelDataHeader), pKernelHeader->m_ParentSamplerParamsOffset);
-    }
-
-    EXPECT_EQ(blockCount, pKernelHeader->m_numberOfKernels);
-    EXPECT_EQ(parentImages, pKernelHeader->m_ParentKernelImageCount);
-    EXPECT_LT(sizeof(IGIL_KernelDataHeader), pKernelHeader->m_ParentImageDataOffset);
-    EXPECT_EQ(parentSamplers, pKernelHeader->m_ParentSamplerCount);
-    EXPECT_NE(pKernelHeader->m_ParentImageDataOffset, pKernelHeader->m_ParentSamplerParamsOffset);
-
-    // Curbe tokens
-    EXPECT_NE(0u, totalCurbeParamsSize);
-
-    for (uint32_t i = 0; i < pKernelHeader->m_numberOfKernels; i++) {
-        IGIL_KernelAddressData *addressData = pKernelHeader->m_data;
-        EXPECT_NE(0u, addressData->m_KernelDataOffset);
-        EXPECT_NE(0u, addressData->m_BTSize);
-        EXPECT_NE(0u, addressData->m_SSHTokensOffset);
-        EXPECT_NE(0u, addressData->m_ConstantBufferOffset);
-        EXPECT_NE(0u, addressData->m_BTSoffset);
-
-        IGIL_KernelData *kernelData = reinterpret_cast<IGIL_KernelData *>(ptrOffset(pKernelHeader, (size_t)(addressData->m_KernelDataOffset)));
-
-        EXPECT_NE_VAL(0u, kernelData->m_SIMDSize);
-        EXPECT_NE_VAL(0u, kernelData->m_PatchTokensMask);
-        EXPECT_NE_VAL(0u, kernelData->m_numberOfCurbeParams);
-        EXPECT_NE_VAL(0u, kernelData->m_numberOfCurbeTokens);
-        EXPECT_NE_VAL(0u, kernelData->m_sizeOfConstantBuffer);
-
-        for (uint32_t j = 0; j < kernelData->m_numberOfCurbeParams; j++) {
-            EXPECT_NE_VAL(0u, kernelData->m_data[j].m_parameterType);
-        }
-    }
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithArgsWhenPassedToGetCurbeParamsThenProperFirstSshTokenIndexIsReturned) {
-
-    KernelInfo info;
-
-    info.kernelDescriptor.payloadMappings.explicitArgs.resize(9);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pDevice->getHardwareInfo());
-
-    EXPECT_EQ(curbeParams.size() - 9, firstSSHTokenIndex);
-}
-
-TEST_P(KernelReflectionSurfaceTest, GivenKernelInfoWithExecutionParametersWhenPassedToGetCurbeParamsThenProperCurbeParamsAreReturned) {
-
-    KernelInfo info;
-
-    std::vector<uint32_t> supportedExecutionParamTypes = {iOpenCL::DATA_PARAMETER_LOCAL_WORK_SIZE,
-                                                          iOpenCL::DATA_PARAMETER_GLOBAL_WORK_SIZE,
-                                                          iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS,
-                                                          iOpenCL::DATA_PARAMETER_WORK_DIMENSIONS,
-                                                          iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET,
-                                                          iOpenCL::DATA_PARAMETER_NUM_HARDWARE_THREADS,
-                                                          iOpenCL::DATA_PARAMETER_PARENT_EVENT,
-                                                          iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE};
-
-    std::sort(supportedExecutionParamTypes.begin(), supportedExecutionParamTypes.end());
-
-    const uint32_t workDimOffset = 80;
-    const uint32_t numHwThreads = 84;
-    const uint32_t parentEventOffset = 88;
-
-    const uint32_t lwsOffsets[3] = {4, 8, 12};
-    const uint32_t lwsOffsets2[3] = {16, 20, 24};
-    const uint32_t gwsOffsets[3] = {28, 32, 36};
-    const uint32_t numOffsets[3] = {40, 44, 48};
-    const uint32_t globalOffsetOffsets[3] = {52, 56, 60};
-    const uint32_t enqueuedLocalWorkSizeOffsets[3] = {64, 68, 72};
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize[0] = lwsOffsets[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize[1] = lwsOffsets[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize[2] = lwsOffsets[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize2[0] = lwsOffsets2[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize2[1] = lwsOffsets2[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.localWorkSize2[2] = lwsOffsets2[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkSize[0] = gwsOffsets[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkSize[1] = gwsOffsets[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkSize[2] = gwsOffsets[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.numWorkGroups[0] = numOffsets[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.numWorkGroups[1] = numOffsets[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.numWorkGroups[2] = numOffsets[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkOffset[0] = globalOffsetOffsets[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkOffset[1] = globalOffsetOffsets[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.globalWorkOffset[2] = globalOffsetOffsets[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[0] = enqueuedLocalWorkSizeOffsets[0];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[1] = enqueuedLocalWorkSizeOffsets[1];
-    info.kernelDescriptor.payloadMappings.dispatchTraits.enqueuedLocalWorkSize[2] = enqueuedLocalWorkSizeOffsets[2];
-
-    info.kernelDescriptor.payloadMappings.dispatchTraits.workDim = workDimOffset;
-    // NUM_HARDWARE_THREADS unsupported
-    EXPECT_TRUE(numHwThreads > 0u);
-    info.kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueParentEvent = parentEventOffset;
-
-    std::vector<IGIL_KernelCurbeParams> curbeParams;
-    uint64_t tokenMask = 0;
-    uint32_t firstSSHTokenIndex = 0;
-    MockKernel::ReflectionSurfaceHelperPublic::getCurbeParams(curbeParams, tokenMask, firstSSHTokenIndex, info, pPlatform->getClDevice(0)->getHardwareInfo());
-
-    EXPECT_LE(supportedExecutionParamTypes.size(), curbeParams.size());
-
-    for (auto paramType : supportedExecutionParamTypes) {
-        auto foundParams = 0u;
-        auto j = 0;
-        for (const auto &curbeParam : curbeParams) {
-            if (paramType == curbeParam.m_parameterType) {
-
-                foundParams++;
-
-                uint32_t index = curbeParam.m_sourceOffset / sizeof(uint32_t);
-
-                switch (paramType) {
-                case iOpenCL::DATA_PARAMETER_LOCAL_WORK_SIZE:
-                    if (j < 3) {
-                        EXPECT_EQ(lwsOffsets[index], curbeParam.m_patchOffset);
-                    } else {
-                        EXPECT_EQ(lwsOffsets2[index], curbeParam.m_patchOffset);
-                    }
-                    break;
-                case iOpenCL::DATA_PARAMETER_GLOBAL_WORK_SIZE:
-                    EXPECT_EQ(gwsOffsets[index], curbeParam.m_patchOffset);
-                    break;
-                case iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS:
-                    EXPECT_EQ(numOffsets[index], curbeParam.m_patchOffset);
-                    break;
-                case iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET:
-                    EXPECT_EQ(globalOffsetOffsets[index], curbeParam.m_patchOffset);
-                    break;
-                case iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE:
-                    EXPECT_EQ(enqueuedLocalWorkSizeOffsets[index], curbeParam.m_patchOffset);
-                    break;
-                }
-            }
-            j++;
-        }
-        switch (paramType) {
-        case iOpenCL::DATA_PARAMETER_LOCAL_WORK_SIZE:
-            EXPECT_EQ(6u, foundParams) << "Parameter token: " << paramType;
-            break;
-        case iOpenCL::DATA_PARAMETER_GLOBAL_WORK_SIZE:
-        case iOpenCL::DATA_PARAMETER_NUM_WORK_GROUPS:
-        case iOpenCL::DATA_PARAMETER_GLOBAL_WORK_OFFSET:
-        case iOpenCL::DATA_PARAMETER_ENQUEUED_LOCAL_WORK_SIZE:
-            EXPECT_EQ(3u, foundParams) << "Parameter token: " << paramType;
-            break;
-        }
-    }
-
-    for (auto paramType : supportedExecutionParamTypes) {
-        auto foundParams = 0u;
-
-        for (const auto &curbeParam : curbeParams) {
-            if (paramType == curbeParam.m_parameterType) {
-
-                switch (paramType) {
-                case iOpenCL::DATA_PARAMETER_PARENT_EVENT:
-                    EXPECT_EQ(parentEventOffset, curbeParam.m_patchOffset);
-                    foundParams++;
-                    break;
-                case iOpenCL::DATA_PARAMETER_WORK_DIMENSIONS:
-                    EXPECT_EQ(workDimOffset, curbeParam.m_patchOffset);
-                    foundParams++;
-                    break;
-                }
-            }
-        }
-
-        switch (paramType) {
-        case iOpenCL::DATA_PARAMETER_PARENT_EVENT:
-        case iOpenCL::DATA_PARAMETER_WORK_DIMENSIONS:
-            EXPECT_EQ(1u, foundParams);
-            break;
-        }
-    }
-
-    for (auto paramType : supportedExecutionParamTypes) {
-        if (paramType != iOpenCL::DATA_PARAMETER_NUM_HARDWARE_THREADS) {
-            auto expectedTokens = (uint64_t)1 << paramType;
-            EXPECT_TRUE((tokenMask & expectedTokens) > 0) << "Parameter Token: " << paramType;
-        }
-    }
-}
-
-static const char *binaryFile = "simple_block_kernel";
-static const char *KernelNames[] = {"kernel_reflection", "simple_block_kernel"};
-
-INSTANTIATE_TEST_CASE_P(KernelReflectionSurfaceTest,
-                        KernelReflectionSurfaceTest,
-                        ::testing::Combine(
-                            ::testing::Values(binaryFile),
-                            ::testing::ValuesIn(KernelNames)));
-
-HWCMDTEST_P(IGFX_GEN8_CORE, KernelReflectionSurfaceWithQueueTest, WhenObtainingKernelReflectionSurfacePatchesThenCurbeIsBlocked) {
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_NE(0u, blockCount);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    pKernel->createReflectionSurface();
-    pKernel->patchReflectionSurface(pDevQueue, nullptr);
-
-    auto *reflectionSurface = pKernel->getKernelReflectionSurface();
-    ASSERT_NE(nullptr, reflectionSurface);
-    void *reflectionSurfaceMemory = reflectionSurface->getUnderlyingBuffer();
-
-    IGIL_KernelDataHeader *pKernelHeader = reinterpret_cast<IGIL_KernelDataHeader *>(reflectionSurface->getUnderlyingBuffer());
-
-    EXPECT_EQ(blockCount, pKernelHeader->m_numberOfKernels);
-
-    for (uint32_t i = 0; i < pKernelHeader->m_numberOfKernels; i++) {
-        const KernelInfo *pBlockInfo = blockManager->getBlockKernelInfo(i);
-
-        IGIL_KernelAddressData *addressData = pKernelHeader->m_data;
-
-        EXPECT_NE(0u, addressData[i].m_ConstantBufferOffset);
-
-        void *pCurbe = ptrOffset(reflectionSurfaceMemory, (size_t)(addressData[i].m_ConstantBufferOffset));
-
-        const auto &eventPoolSurfaceAddress = pBlockInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueEventPoolSurfaceAddress;
-        if (isValidOffset(eventPoolSurfaceAddress.stateless)) {
-            auto *patchedPointer = ptrOffset(pCurbe, eventPoolSurfaceAddress.stateless);
-            if (eventPoolSurfaceAddress.pointerSize == sizeof(uint32_t)) {
-                uint32_t *patchedValue = static_cast<uint32_t *>(patchedPointer);
-                uint64_t patchedValue64 = *patchedValue;
-                EXPECT_EQ(pDevQueue->getEventPoolBuffer()->getGpuAddress(), patchedValue64);
-            } else if (eventPoolSurfaceAddress.pointerSize == sizeof(uint64_t)) {
-                uint64_t *patchedValue = static_cast<uint64_t *>(patchedPointer);
-                EXPECT_EQ(pDevQueue->getEventPoolBuffer()->getGpuAddress(), *patchedValue);
-            }
-        }
-
-        const auto &defaultQueueSurfaceAddress = pBlockInfo->kernelDescriptor.payloadMappings.implicitArgs.deviceSideEnqueueDefaultQueueSurfaceAddress;
-        if (isValidOffset(defaultQueueSurfaceAddress.stateless)) {
-            auto *patchedPointer = ptrOffset(pCurbe, defaultQueueSurfaceAddress.stateless);
-            if (defaultQueueSurfaceAddress.pointerSize == sizeof(uint32_t)) {
-                uint32_t *patchedValue = static_cast<uint32_t *>(patchedPointer);
-                uint64_t patchedValue64 = *patchedValue;
-                EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), patchedValue64);
-            } else if (defaultQueueSurfaceAddress.pointerSize == sizeof(uint64_t)) {
-                uint64_t *patchedValue = static_cast<uint64_t *>(patchedPointer);
-                EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), *patchedValue);
-            }
-        }
-
-        for (const auto &arg : pBlockInfo->getExplicitArgs()) {
-            if (arg.getExtendedTypeInfo().isDeviceQueue) {
-                auto &asPtr = arg.as<ArgDescPointer>();
-                auto *patchedPointer = ptrOffset(pCurbe, asPtr.stateless);
-                if (asPtr.pointerSize == sizeof(uint32_t)) {
-                    uint32_t *patchedValue = static_cast<uint32_t *>(patchedPointer);
-                    uint64_t patchedValue64 = *patchedValue;
-                    EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), patchedValue64);
-                } else if (asPtr.pointerSize == sizeof(uint64_t)) {
-                    uint64_t *patchedValue = static_cast<uint64_t *>(patchedPointer);
-                    EXPECT_EQ(pDevQueue->getQueueBuffer()->getGpuAddress(), *patchedValue);
-                }
-            }
-        }
-    }
-}
-
-HWCMDTEST_P(IGFX_GEN8_CORE, KernelReflectionSurfaceWithQueueTest, WhenObtainingKernelReflectionSurfaceThenParentImageAndSamplersParamsAreSet) {
-    BlockKernelManager *blockManager = pProgram->getBlockKernelManager();
-    size_t blockCount = blockManager->getCount();
-
-    EXPECT_NE(0u, blockCount);
-
-    std::vector<IGIL_KernelCurbeParams> curbeParamsForBlock;
-
-    std::unique_ptr<Image> image3d(ImageHelper<Image3dDefaults>::create(context));
-    std::unique_ptr<Sampler> sampler(new MockSampler(context,
-                                                     true,
-                                                     (cl_addressing_mode)CL_ADDRESS_CLAMP_TO_EDGE,
-                                                     (cl_filter_mode)CL_FILTER_LINEAR));
-
-    cl_sampler samplerCl = sampler.get();
-    cl_mem imageCl = image3d.get();
-
-    if (pKernel->getKernelInfo().kernelDescriptor.kernelMetadata.kernelName == "kernel_reflection") {
-        pKernel->setArgSampler(0, sizeof(cl_sampler), &samplerCl);
-        pKernel->setArgImage(1, sizeof(cl_mem), &imageCl);
-    }
-
-    pKernel->createReflectionSurface();
-
-    auto *reflectionSurface = pKernel->getKernelReflectionSurface();
-    ASSERT_NE(nullptr, reflectionSurface);
-
-    IGIL_KernelDataHeader *pKernelHeader = reinterpret_cast<IGIL_KernelDataHeader *>(reflectionSurface->getUnderlyingBuffer());
-    IGIL_ImageParamters *pParentImageParams = reinterpret_cast<IGIL_ImageParamters *>(ptrOffset(pKernelHeader, (size_t)pKernelHeader->m_ParentImageDataOffset));
-    IGIL_ParentSamplerParams *pParentSamplerParams = reinterpret_cast<IGIL_ParentSamplerParams *>(ptrOffset(pKernelHeader, (size_t)pKernelHeader->m_ParentSamplerParamsOffset));
-
-    memset(pParentImageParams, 0xff, sizeof(IGIL_ImageParamters) * pKernelHeader->m_ParentKernelImageCount);
-    memset(pParentSamplerParams, 0xff, sizeof(IGIL_ParentSamplerParams) * pKernelHeader->m_ParentSamplerCount);
-
-    pKernel->patchReflectionSurface(pDevQueue, nullptr);
-
-    EXPECT_EQ(blockCount, pKernelHeader->m_numberOfKernels);
-
-    for (uint32_t i = 0; i < pKernelHeader->m_numberOfKernels; i++) {
-
-        if (pKernelHeader->m_ParentKernelImageCount > 0) {
-            uint32_t imageIndex = 0;
-            for (const auto &arg : pKernel->getKernelInfo().getExplicitArgs()) {
-                if (arg.is<ArgDescriptor::ArgTImage>()) {
-                    const auto &asImg = arg.as<ArgDescImage>();
-                    EXPECT_EQ(pParentImageParams[imageIndex].m_ObjectID, asImg.bindful);
-                    imageIndex++;
-                }
-            }
-        }
-
-        if (pKernelHeader->m_ParentSamplerCount > 0) {
-            uint32_t samplerIndex = 0;
-            for (const auto &arg : pKernel->getKernelInfo().getExplicitArgs()) {
-                if (arg.is<ArgDescriptor::ArgTSampler>()) {
-                    const auto &asSmp = arg.as<ArgDescSampler>();
-                    EXPECT_EQ(pParentSamplerParams[samplerIndex].m_ObjectID, static_cast<uint>(OCLRT_ARG_OFFSET_TO_SAMPLER_OBJECT_ID(asSmp.bindful)));
-                    samplerIndex++;
-                }
-            }
-        }
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(KernelReflectionSurfaceWithQueueTest,
-                        KernelReflectionSurfaceWithQueueTest,
-                        ::testing::Combine(
-                            ::testing::Values(binaryFile),
-                            ::testing::ValuesIn(KernelNames)));
-
 class ReflectionSurfaceHelperTest : public testing::TestWithParam<std::tuple<const IGIL_KernelCurbeParams, const IGIL_KernelCurbeParams, bool>> {
 
   protected:
@@ -1646,63 +679,6 @@ TEST_F(ReflectionSurfaceHelperFixture, GivenUndefinedOffsetsWhenPatchingBlocksCu
     EXPECT_THAT(patchedValues, MemCompare(reference.get(), 10 * sizeof(IGIL_KernelDataHeader) - constBufferOffset));
 }
 
-typedef ParentKernelCommandQueueFixture ReflectionSurfaceTestForPrintfHandler;
-
-TEST_F(ReflectionSurfaceTestForPrintfHandler, GivenPrintfHandlerWhenPatchingReflectionSurfaceThenPrintBufferIsPatched) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device);
-    MockContext context(device);
-    cl_queue_properties properties[3] = {0};
-    MockParentKernel::CreateParams createParams{};
-    createParams.addPrintfForBlock = true;
-    createParams.addPrintfForParent = true;
-    std::unique_ptr<MockParentKernel> parentKernel(MockParentKernel::create(context, createParams));
-
-    DeviceQueue devQueue(&context, device, properties[0]);
-    parentKernel->createReflectionSurface();
-
-    context.setDefaultDeviceQueue(&devQueue);
-
-    MockMultiDispatchInfo multiDispatchInfo(device, parentKernel.get());
-    PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, *device);
-    printfHandler->prepareDispatch(multiDispatchInfo);
-
-    parentKernel->patchReflectionSurface<true>(&devQueue, printfHandler);
-
-    const auto &printfSurfaceArg = parentKernel->getProgram()->getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.payloadMappings.implicitArgs.printfSurfaceAddress;
-    EXPECT_EQ(printfSurfaceArg.stateless, MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.offset);
-    EXPECT_EQ(printfHandler->getSurface()->getGpuAddress(), MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.address);
-    EXPECT_EQ(printfSurfaceArg.pointerSize, MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.size);
-
-    delete printfHandler;
-}
-
-TEST_F(ReflectionSurfaceTestForPrintfHandler, GivenNoPrintfSurfaceWhenPatchingReflectionSurfaceThenPrintBufferIsNotPatched) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device);
-    MockContext context(device);
-    cl_queue_properties properties[3] = {0};
-    MockParentKernel::CreateParams createParams{};
-    createParams.addPrintfForBlock = true;
-    createParams.addPrintfForParent = true;
-    std::unique_ptr<MockParentKernel> parentKernel(MockParentKernel::create(context, createParams));
-
-    DeviceQueue devQueue(&context, device, properties[0]);
-    parentKernel->createReflectionSurface();
-
-    context.setDefaultDeviceQueue(&devQueue);
-
-    MockMultiDispatchInfo multiDispatchInfo(device, parentKernel.get());
-    PrintfHandler *printfHandler = PrintfHandler::create(multiDispatchInfo, *device);
-
-    parentKernel->patchReflectionSurface<true>(&devQueue, printfHandler);
-
-    const auto &printfSurfaceArg = parentKernel->getProgram()->getBlockKernelManager()->getBlockKernelInfo(0)->kernelDescriptor.payloadMappings.implicitArgs.printfSurfaceAddress;
-    EXPECT_EQ(printfSurfaceArg.stateless, MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.offset);
-    EXPECT_EQ(0U, MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.address);
-    EXPECT_EQ(printfSurfaceArg.pointerSize, MockKernel::ReflectionSurfaceHelperPublic::printfBuffer.size);
-
-    delete printfHandler;
-}
-
 class ReflectionSurfaceConstantValuesPatchingTest : public ClDeviceFixture,
                                                     public ::testing::Test {
   public:
@@ -1867,83 +843,3 @@ TEST_F(ReflectionSurfaceConstantValuesPatchingTest, GivenBlockWithConstantMemory
     //memory after is not written
     EXPECT_THAT(zeroMemory.get(), MemCompare(pCurbeToPatch + 1, std::min(4096u, 8192u - constBufferOffset - blockPatchOffset - (uint32_t)sizeof(uint64_t))));
 }
-
-using KernelReflectionMultiDeviceTest = MultiRootDeviceFixture;
-
-TEST_F(KernelReflectionMultiDeviceTest, GivenNoKernelArgsWhenObtainingKernelReflectionSurfaceThenParamsAreCorrect) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device1);
-
-    MockProgram program(context.get(), false, toClDeviceVector(*device1));
-    MockKernelInfo *blockInfo = new MockKernelInfo;
-    MockKernelInfo &info = *blockInfo;
-    cl_queue_properties properties[1] = {0};
-    DeviceQueue devQueue(context.get(), device1, properties[0]);
-
-    info.kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
-    info.setCrossThreadDataSize(0);
-    info.setBindingTable(0, 0);
-
-    MockKernel kernel(&program, info, *device1);
-
-    EXPECT_TRUE(kernel.isParentKernel);
-
-    program.blockKernelManager->addBlockKernelInfo(blockInfo);
-
-    kernel.createReflectionSurface();
-    auto reflectionSurface = kernel.getKernelReflectionSurface();
-    ASSERT_NE(nullptr, reflectionSurface);
-    EXPECT_EQ(expectedRootDeviceIndex, reflectionSurface->getRootDeviceIndex());
-
-    kernel.patchReflectionSurface<true>(&devQueue, nullptr);
-
-    uint64_t undefinedOffset = MockKernel::ReflectionSurfaceHelperPublic::undefinedOffset;
-
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::devQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::eventPool.offset);
-
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::devQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::eventPool.size);
-}
-
-TEST_F(KernelReflectionMultiDeviceTest, GivenDeviceQueueKernelArgWhenObtainingKernelReflectionSurfaceThenParamsAreCorrect) {
-    REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device1);
-
-    MockProgram program(context.get(), false, toClDeviceVector(*device1));
-
-    MockKernelInfo *blockInfo = new MockKernelInfo;
-    MockKernelInfo &info = *blockInfo;
-    cl_queue_properties properties[1] = {0};
-    DeviceQueue devQueue(context.get(), device1, properties[0]);
-
-    uint32_t devQueueCurbeOffset = 16;
-    uint32_t devQueueCurbeSize = 4;
-
-    info.kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue = true;
-    info.setCrossThreadDataSize(0);
-    info.setBindingTable(0, 0);
-    info.addArgDevQueue(0, devQueueCurbeOffset, devQueueCurbeSize);
-
-    MockKernel kernel(&program, info, *device1);
-
-    EXPECT_TRUE(kernel.isParentKernel);
-
-    program.blockKernelManager->addBlockKernelInfo(blockInfo);
-
-    kernel.createReflectionSurface();
-    auto reflectionSurface = kernel.getKernelReflectionSurface();
-    ASSERT_NE(nullptr, reflectionSurface);
-    EXPECT_EQ(expectedRootDeviceIndex, reflectionSurface->getRootDeviceIndex());
-
-    kernel.patchReflectionSurface<true>(&devQueue, nullptr);
-    uint64_t undefinedOffset = MockKernel::ReflectionSurfaceHelperPublic::undefinedOffset;
-
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.offset);
-    EXPECT_EQ(devQueueCurbeOffset, MockKernel::ReflectionSurfaceHelperPublic::devQueue.offset);
-    EXPECT_EQ(undefinedOffset, MockKernel::ReflectionSurfaceHelperPublic::eventPool.offset);
-
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::defaultQueue.size);
-    EXPECT_EQ(4u, MockKernel::ReflectionSurfaceHelperPublic::devQueue.size);
-    EXPECT_EQ(0u, MockKernel::ReflectionSurfaceHelperPublic::eventPool.size);
-}
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
index 89517bdb6c..123c97486c 100644
--- a/opencl/test/unit_test/kernel/kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -441,24 +441,6 @@ typedef Test<ClDeviceFixture> KernelPrivateSurfaceTest;
 typedef Test<ClDeviceFixture> KernelGlobalSurfaceTest;
 typedef Test<ClDeviceFixture> KernelConstantSurfaceTest;
 
-struct KernelWithDeviceQueueFixture : public ClDeviceFixture,
-                                      public DeviceQueueFixture,
-                                      public testing::Test {
-    void SetUp() override {
-        ClDeviceFixture::SetUp();
-        DeviceQueueFixture::SetUp(&context, pClDevice);
-    }
-    void TearDown() override {
-        DeviceQueueFixture::TearDown();
-        ClDeviceFixture::TearDown();
-    }
-
-    MockContext context;
-};
-
-typedef KernelWithDeviceQueueFixture KernelDefaultDeviceQueueSurfaceTest;
-typedef KernelWithDeviceQueueFixture KernelEventPoolSurfaceTest;
-
 class CommandStreamReceiverMock : public CommandStreamReceiver {
     typedef CommandStreamReceiver BaseClass;
 
diff --git a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp b/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
index a25c825d80..d50eeeb65b 100644
--- a/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
+++ b/opencl/test/unit_test/kernel/parent_kernel_tests.cpp
@@ -8,7 +8,7 @@
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/test_macros/test.h"
 
-#include "opencl/test/unit_test/fixtures/execution_model_kernel_fixture.h"
+#include "opencl/test/unit_test/mocks/mock_cl_device.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
 #include "opencl/test/unit_test/mocks/mock_program.h"
 
@@ -143,16 +143,4 @@ TEST(ParentKernelTest, WhenInitializingParentKernelThenPrivateMemoryForBlocksIsA
     parentKernel->initialize();
 
     EXPECT_NE(nullptr, program->getBlockKernelManager()->getPrivateSurface(program->getBlockKernelManager()->getCount() - 1));
-}
-
-struct ParentKernelFromBinaryTest : public ExecutionModelKernelFixture {
-
-    void SetUp() override {
-        ExecutionModelKernelFixture::SetUp("simple_block_kernel", "simple_block_kernel");
-    }
-};
-
-TEST_F(ParentKernelFromBinaryTest, GivenParentKernelWhenGettingInstructionHeapSizeForExecutionModelThenSizeIsGreaterThanZero) {
-    EXPECT_TRUE(pKernel->isParentKernel);
-    EXPECT_LT(0u, pKernel->getInstructionHeapSizeForExecutionModel());
-}
+}
\ No newline at end of file
diff --git a/opencl/test/unit_test/test_macros/test_checks_ocl.h b/opencl/test/unit_test/test_macros/test_checks_ocl.h
index 06741084ce..af85d79666 100644
--- a/opencl/test/unit_test/test_macros/test_checks_ocl.h
+++ b/opencl/test/unit_test/test_macros/test_checks_ocl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -41,11 +41,6 @@ bool supportsAuxResolves();
         GTEST_SKIP();                                     \
     }
 
-#define REQUIRE_DEVICE_ENQUEUE_OR_SKIP(param)                     \
-    if (NEO::TestChecks::supportsDeviceEnqueue(param) == false) { \
-        GTEST_SKIP();                                             \
-    }
-
 #define REQUIRE_AUX_RESOLVES()                             \
     if (NEO::TestChecks::supportsAuxResolves() == false) { \
         GTEST_SKIP();                                      \