Refactoring ULTs around HW tests

Splitting HW tests into CMD-unrelated HW tests and CMD-related HW tests Change-Id: Ifbdcabdd0d6f4082e976363a3d8bcd5e7a9ce6c1
2026-01-08 22:12:59 +08:00 · 2018-05-18 11:45:45 +02:00
parent bcda4ce071
commit b27eee1f7a
42 changed files with 504 additions and 366 deletions
--- a/runtime/gen8/hw_cmds.h
+++ b/runtime/gen8/hw_cmds.h
@@ -312,7 +312,12 @@ struct BDWFamily : public GEN8 {
    static const MI_BATCH_BUFFER_END cmdInitBatchBufferEnd;
    static const MI_BATCH_BUFFER_START cmdInitBatchBufferStart;
    static const PIPE_CONTROL cmdInitPipeControl;
+
+    static constexpr bool supportsCmdSet(GFXCORE_FAMILY cmdSetBaseFamily) {
+        return cmdSetBaseFamily == IGFX_GEN8_CORE;
+    }
 };
+
 struct BDW : public BDWFamily {
    static const PLATFORM platform;
    static const HardwareInfo hwInfo;
--- a/runtime/gen9/hw_cmds_base.h
+++ b/runtime/gen9/hw_cmds_base.h
@@ -47,5 +47,10 @@ struct SKLFamily : public GEN9 {
    static const MI_BATCH_BUFFER_END cmdInitBatchBufferEnd;
    static const MI_BATCH_BUFFER_START cmdInitBatchBufferStart;
    static const PIPE_CONTROL cmdInitPipeControl;
+
+    static constexpr bool supportsCmdSet(GFXCORE_FAMILY cmdSetBaseFamily) {
+        return cmdSetBaseFamily == IGFX_GEN8_CORE;
+    }
 };
+
 } // namespace OCLRT
--- a/unit_tests/built_ins/scheduler_source_tests.cpp
+++ b/unit_tests/built_ins/scheduler_source_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -53,8 +53,7 @@ class SchedulerSourceTest : public testing::Test {
    MockContext context;
 };

-HWTEST_F(SchedulerSourceTest, PatchGpgpuWalker) {
-
+HWCMDTEST_F(IGFX_GEN8_CORE, SchedulerSourceTest, PatchGpgpuWalker) {
    using MEDIA_STATE_FLUSH = typename FamilyType::MEDIA_STATE_FLUSH;
    using MEDIA_INTERFACE_DESCRIPTOR_LOAD = typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
--- a/unit_tests/command_queue/dispatch_walker_tests.cpp
+++ b/unit_tests/command_queue/dispatch_walker_tests.cpp
@@ -115,7 +115,7 @@ HWTEST_F(DispatchWalkerTest, computeDimensions) {
    EXPECT_EQ(3u, computeDimensions(workItems3D));
 }

-HWTEST_F(DispatchWalkerTest, shouldntChangeCommandStreamMemory) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, shouldntChangeCommandStreamMemory) {
    MockKernel kernel(&program, kernelInfo, *pDevice);
    ASSERT_EQ(CL_SUCCESS, kernel.initialize());

@@ -158,7 +158,7 @@ HWTEST_F(DispatchWalkerTest, shouldntChangeCommandStreamMemory) {
    EXPECT_EQ(sizeDispatchWalkerNeeds, commandStream.getUsed() - commandStreamStart);
 }

-HWTEST_F(DispatchWalkerTest, noLocalIdsShouldntCrash) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, noLocalIdsShouldntCrash) {
    threadPayload.LocalIDXPresent = 0;
    threadPayload.LocalIDYPresent = 0;
    threadPayload.LocalIDZPresent = 0;
@@ -777,7 +777,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfo) {
    }
 }

-HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProgramsInterfaceDesriptors) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProgramsInterfaceDesriptors) {
    using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;

    auto memoryManager = this->pDevice->getMemoryManager();
@@ -872,7 +872,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProg
    memoryManager->freeGraphicsMemory(kernelIsaWithSamplerAllocation);
 }

-HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProgramsGpgpuWalkerIDOffset) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProgramsGpgpuWalkerIDOffset) {
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;

    MockKernel kernel1(&program, kernelInfo, *pDevice);
@@ -917,7 +917,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoCorrectlyProg
    }
 }

-HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoAndDifferentKernelsCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoAndDifferentKernelsCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;

    MockKernel kernel1(&program, kernelInfo, *pDevice);
@@ -966,7 +966,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoAndDifferentK
    }
 }

-HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoButSameKernelCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoButSameKernelCorrectlyProgramsGpgpuWalkerThreadGroupIdStartingCoordinates) {
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;

    MockKernel kernel(&program, kernelInfo, *pDevice);
@@ -1016,7 +1016,7 @@ HWTEST_F(DispatchWalkerTest, dispatchWalkerWithMultipleDispatchInfoButSameKernel
    }
 }

-HWTEST_F(DispatchWalkerTest, givenMultiDispatchWhenWhitelistedRegisterForCoherencySwitchThenDontProgramLriInTaskStream) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DispatchWalkerTest, givenMultiDispatchWhenWhitelistedRegisterForCoherencySwitchThenDontProgramLriInTaskStream) {
    typedef typename FamilyType::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
    WhitelistedRegisters registers = {0};
    registers.chicken0hdc_0xE5F0 = true;
--- a/unit_tests/command_queue/enqueue_copy_buffer_fixture.h
+++ b/unit_tests/command_queue/enqueue_copy_buffer_fixture.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -80,7 +80,6 @@ struct EnqueueCopyBufferTest : public CommandEnqueueFixture,
    }

  protected:
-    template <typename FamilyType>
    void enqueueCopyBuffer() {
        auto retVal = EnqueueCopyBufferHelper::enqueueCopyBuffer(
            pCmdQ,
@@ -93,7 +92,11 @@ struct EnqueueCopyBufferTest : public CommandEnqueueFixture,
            nullptr,
            nullptr);
        EXPECT_EQ(CL_SUCCESS, retVal);
+    }

+    template <typename FamilyType>
+    void enqueueCopyBufferAndParse() {
+        enqueueCopyBuffer();
        parseCommands<FamilyType>(*pCmdQ);
    }

--- a/unit_tests/command_queue/enqueue_copy_buffer_rect_tests.cpp
+++ b/unit_tests/command_queue/enqueue_copy_buffer_rect_tests.cpp
@@ -105,7 +105,7 @@ HWTEST_F(EnqueueCopyBufferRectTest, returnSuccess) {
    EXPECT_EQ(CL_SUCCESS, retVal);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, alignsToCSR) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, alignsToCSR) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -116,7 +116,7 @@ HWTEST_F(EnqueueCopyBufferRectTest, alignsToCSR) {
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueCopyBufferRect2D<FamilyType>();

@@ -148,21 +148,21 @@ HWTEST_F(EnqueueCopyBufferRectTest, 2D_GPGPUWalker) {
    }
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_bumpsTaskLevel) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    enqueueCopyBufferRect2D<FamilyType>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_addsCommands) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    enqueueCopyBufferRect2D<FamilyType>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_addsIndirectData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_addsIndirectData) {
    auto dshBefore = pDSH->getUsed();
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();
@@ -198,18 +198,18 @@ HWTEST_F(EnqueueCopyBufferRectTest, 2D_addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
    enqueueCopyBufferRect2D<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueCopyBufferRect2D<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -234,7 +234,7 @@ HWTEST_F(EnqueueCopyBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -253,13 +253,13 @@ HWTEST_F(EnqueueCopyBufferRectTest, 2D_InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_PipelineSelect) {
    enqueueCopyBufferRect2D<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 2D_MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 2D_MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueCopyBufferRect2D<FamilyType>();
@@ -275,7 +275,7 @@ HWTEST_F(EnqueueCopyBufferRectTest, 2D_MediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueCopyBufferRect3D<FamilyType>();

@@ -310,39 +310,39 @@ HWTEST_F(EnqueueCopyBufferRectTest, 3D_GPGPUWalker) {
    //EXPECT_EQ( expectedWorkItems, numWorkItems );
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_bumpsTaskLevel) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    enqueueCopyBufferRect3D<FamilyType>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_addsCommands) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    enqueueCopyBufferRect3D<FamilyType>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_addsIndirectData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_addsIndirectData) {
    auto usedIndirectHeapBefore = pDSH->getUsed();

    enqueueCopyBufferRect3D<FamilyType>();
    EXPECT_NE(usedIndirectHeapBefore, pDSH->getUsed());
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_LoadRegisterImmediateL3CNTLREG) {
    enqueueCopyBufferRect3D<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, When3DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, When3DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueCopyBufferRect3D<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -367,7 +367,7 @@ HWTEST_F(EnqueueCopyBufferRectTest, 3D_MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -386,13 +386,13 @@ HWTEST_F(EnqueueCopyBufferRectTest, 3D_InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_PipelineSelect) {
    enqueueCopyBufferRect3D<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyBufferRectTest, 3D_MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferRectTest, 3D_MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueCopyBufferRect3D<FamilyType>();
--- a/unit_tests/command_queue/enqueue_copy_buffer_tests.cpp
+++ b/unit_tests/command_queue/enqueue_copy_buffer_tests.cpp
@@ -86,14 +86,14 @@ HWTEST_F(EnqueueCopyBufferTest, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBuffer();
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueCopyBufferTest, GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBufferAndParse<FamilyType>();

    auto *cmd = (GPGPU_WALKER *)cmdWalker;
    ASSERT_NE(nullptr, cmd);
@@ -125,14 +125,14 @@ HWTEST_F(EnqueueCopyBufferTest, GPGPUWalker) {
 HWTEST_F(EnqueueCopyBufferTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBuffer();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueCopyBufferTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBuffer();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -141,7 +141,7 @@ HWTEST_F(EnqueueCopyBufferTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBuffer();

    MultiDispatchInfo multiDispatchInfo;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
@@ -166,22 +166,22 @@ HWTEST_F(EnqueueCopyBufferTest, addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueCopyBufferTest, LoadRegisterImmediateL3CNTLREG) {
-    enqueueCopyBuffer<FamilyType>();
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, LoadRegisterImmediateL3CNTLREG) {
+    enqueueCopyBufferAndParse<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyBufferTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
-    enqueueCopyBuffer<FamilyType>();
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+    enqueueCopyBufferAndParse<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyBufferTest, MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBufferAndParse<FamilyType>();

    auto *cmd = (MEDIA_INTERFACE_DESCRIPTOR_LOAD *)cmdMediaInterfaceDescriptorLoad;
    ASSERT_NE(nullptr, cmd);
@@ -202,12 +202,12 @@ HWTEST_F(EnqueueCopyBufferTest, MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyBufferTest, InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBufferAndParse<FamilyType>();

    auto cmdIDD = (INTERFACE_DESCRIPTOR_DATA *)cmdInterfaceDescriptorData;
    auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
@@ -221,16 +221,16 @@ HWTEST_F(EnqueueCopyBufferTest, InterfaceDescriptorData) {
    EXPECT_NE(0u, cmdIDD->getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueCopyBufferTest, PipelineSelect) {
-    enqueueCopyBuffer<FamilyType>();
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, PipelineSelect) {
+    enqueueCopyBufferAndParse<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyBufferTest, MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

-    enqueueCopyBuffer<FamilyType>();
+    enqueueCopyBufferAndParse<FamilyType>();

    auto *cmd = (MEDIA_VFE_STATE *)cmdMediaVfeState;
    ASSERT_NE(nullptr, cmd);
@@ -244,8 +244,8 @@ HWTEST_F(EnqueueCopyBufferTest, MediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
 }

-HWTEST_F(EnqueueCopyBufferTest, argumentZeroShouldMatchSourceAddress) {
-    enqueueCopyBuffer<FamilyType>();
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, argumentZeroShouldMatchSourceAddress) {
+    enqueueCopyBufferAndParse<FamilyType>();

    // Extract the kernel used
    MultiDispatchInfo multiDispatchInfo;
@@ -271,8 +271,8 @@ HWTEST_F(EnqueueCopyBufferTest, argumentZeroShouldMatchSourceAddress) {
    EXPECT_EQ((void *)((uintptr_t)srcBuffer->getGraphicsAllocation()->getGpuAddress()), *pArgument);
 }

-HWTEST_F(EnqueueCopyBufferTest, argumentOneShouldMatchDestAddress) {
-    enqueueCopyBuffer<FamilyType>();
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferTest, argumentOneShouldMatchDestAddress) {
+    enqueueCopyBufferAndParse<FamilyType>();

    // Extract the kernel used
    MultiDispatchInfo multiDispatchInfo;
--- a/unit_tests/command_queue/enqueue_copy_buffer_to_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_copy_buffer_to_image_tests.cpp
@@ -30,7 +30,7 @@

 using namespace OCLRT;

-HWTEST_F(EnqueueCopyBufferToImageTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueCopyBufferToImage<FamilyType>();

@@ -67,7 +67,7 @@ HWTEST_F(EnqueueCopyBufferToImageTest, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueCopyBufferToImage<FamilyType>();
+    EnqueueCopyBufferToImageHelper<>::enqueueCopyBufferToImage(pCmdQ, srcBuffer, dstImage);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -75,14 +75,14 @@ HWTEST_F(EnqueueCopyBufferToImageTest, alignsToCSR) {
 HWTEST_F(EnqueueCopyBufferToImageTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueCopyBufferToImage<FamilyType>();
+    EnqueueCopyBufferToImageHelper<>::enqueueCopyBufferToImage(pCmdQ, srcBuffer, dstImage);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueCopyBufferToImageTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueCopyBufferToImage<FamilyType>();
+    EnqueueCopyBufferToImageHelper<>::enqueueCopyBufferToImage(pCmdQ, srcBuffer, dstImage);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -91,24 +91,24 @@ HWTEST_F(EnqueueCopyBufferToImageTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueCopyBufferToImage<FamilyType>();
+    EnqueueCopyBufferToImageHelper<>::enqueueCopyBufferToImage(pCmdQ, srcBuffer, dstImage);
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, loadRegisterImmediateL3CNTLREG) {
    enqueueCopyBufferToImage<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueCopyBufferToImage<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -134,7 +134,7 @@ HWTEST_F(EnqueueCopyBufferToImageTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -161,7 +161,7 @@ HWTEST_F(EnqueueCopyBufferToImageTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueCopyBufferToImage<FamilyType>();
@@ -186,13 +186,13 @@ HWTEST_F(EnqueueCopyBufferToImageTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(dstImage->getCpuAddress()), surfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, pipelineSelect) {
    enqueueCopyBufferToImage<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyBufferToImageTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyBufferToImageTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueCopyBufferToImage<FamilyType>();
--- a/unit_tests/command_queue/enqueue_copy_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_copy_image_tests.cpp
@@ -30,7 +30,7 @@

 using namespace OCLRT;

-HWTEST_F(EnqueueCopyImageTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueCopyImage<FamilyType>();

@@ -70,7 +70,7 @@ HWTEST_F(EnqueueCopyImageTest, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueCopyImage<FamilyType>();
+    EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -78,14 +78,14 @@ HWTEST_F(EnqueueCopyImageTest, alignsToCSR) {
 HWTEST_F(EnqueueCopyImageTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueCopyImage<FamilyType>();
+    EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueCopyImageTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueCopyImage<FamilyType>();
+    EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -94,24 +94,24 @@ HWTEST_F(EnqueueCopyImageTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueCopyImage<FamilyType>();
+    EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueCopyImageTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, loadRegisterImmediateL3CNTLREG) {
    enqueueCopyImage<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueCopyImage<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyImageTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -137,7 +137,7 @@ HWTEST_F(EnqueueCopyImageTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyImageTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -164,7 +164,7 @@ HWTEST_F(EnqueueCopyImageTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueCopyImageTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueCopyImage<FamilyType>();
@@ -195,13 +195,13 @@ HWTEST_F(EnqueueCopyImageTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(dstImage->getCpuAddress()), dstSurfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueCopyImageTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, pipelineSelect) {
    enqueueCopyImage<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyImageTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueCopyImage<FamilyType>();
--- a/unit_tests/command_queue/enqueue_copy_image_to_buffer_tests.cpp
+++ b/unit_tests/command_queue/enqueue_copy_image_to_buffer_tests.cpp
@@ -30,7 +30,7 @@

 using namespace OCLRT;

-HWTEST_F(EnqueueCopyImageToBufferTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueCopyImageToBuffer<FamilyType>();

@@ -62,7 +62,7 @@ HWTEST_F(EnqueueCopyImageToBufferTest, gpgpuWalker) {
    }
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, alignsToCSR) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, alignsToCSR) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -73,21 +73,21 @@ HWTEST_F(EnqueueCopyImageToBufferTest, alignsToCSR) {
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, bumpsTaskLevel) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    enqueueCopyImageToBuffer<FamilyType>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, addsCommands) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    enqueueCopyImageToBuffer<FamilyType>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, addsIndirectData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, addsIndirectData) {
    auto dshBefore = pDSH->getUsed();
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();
@@ -98,18 +98,18 @@ HWTEST_F(EnqueueCopyImageToBufferTest, addsIndirectData) {
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, loadRegisterImmediateL3CNTLREG) {
    enqueueCopyImageToBuffer<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueCopyImageToBuffer<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -135,7 +135,7 @@ HWTEST_F(EnqueueCopyImageToBufferTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -162,7 +162,7 @@ HWTEST_F(EnqueueCopyImageToBufferTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueCopyImageToBuffer<FamilyType>();
@@ -187,13 +187,13 @@ HWTEST_F(EnqueueCopyImageToBufferTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(srcImage->getCpuAddress()), surfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, pipelineSelect) {
    enqueueCopyImageToBuffer<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueCopyImageToBufferTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageToBufferTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueCopyImageToBuffer<FamilyType>();
--- a/unit_tests/command_queue/enqueue_fill_buffer_tests.cpp
+++ b/unit_tests/command_queue/enqueue_fill_buffer_tests.cpp
@@ -44,7 +44,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -52,12 +52,12 @@ HWTEST_F(EnqueueFillBufferCmdTests, alignsToCSR) {
 HWTEST_F(EnqueueFillBufferCmdTests, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueFillBufferCmdTests, setsBufferCompletionStamp) {
-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    auto deviceEngineType = pDevice->getEngineType();
    auto &commandStreamReceiver = pDevice->getCommandStreamReceiver();
    EXPECT_EQ(commandStreamReceiver.peekTaskCount(), buffer->getCompletionStamp().taskCount);
@@ -68,11 +68,11 @@ HWTEST_F(EnqueueFillBufferCmdTests, setsBufferCompletionStamp) {
 HWTEST_F(EnqueueFillBufferCmdTests, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueFillBufferCmdTests, GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

    enqueueFillBuffer<FamilyType>();
@@ -111,7 +111,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);

    MultiDispatchInfo multiDispatchInfo;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
@@ -142,7 +142,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, addsIndirectData) {
 HWTEST_F(EnqueueFillBufferCmdTests, FillBufferRightLeftover) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);

    MultiDispatchInfo mdi;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
@@ -168,7 +168,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferRightLeftover) {
 HWTEST_F(EnqueueFillBufferCmdTests, FillBufferMiddle) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);

    MultiDispatchInfo mdi;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
@@ -194,7 +194,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferMiddle) {
 HWTEST_F(EnqueueFillBufferCmdTests, FillBufferLeftLeftover) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);

    MultiDispatchInfo mdi;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::FillBuffer,
@@ -217,18 +217,18 @@ HWTEST_F(EnqueueFillBufferCmdTests, FillBufferLeftLeftover) {
    context.getMemoryManager()->freeGraphicsMemory(patternAllocation);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, LoadRegisterImmediateL3CNTLREG) {
    enqueueFillBuffer<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueFillBuffer<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -252,7 +252,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, InterfaceDescriptorData) {
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;

@@ -271,13 +271,13 @@ HWTEST_F(EnqueueFillBufferCmdTests, InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueFillBufferCmdTests, PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, PipelineSelect) {
    enqueueFillBuffer<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueFillBuffer<FamilyType>();
@@ -294,7 +294,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, MediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, argumentZeroShouldMatchDestAddress) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, argumentZeroShouldMatchDestAddress) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

    enqueueFillBuffer<FamilyType>();
@@ -329,7 +329,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, argumentZeroShouldMatchDestAddress) {
 // This test case should be re-enabled once getStatelessArgumentPointer gets support for SVM pointers.
 // This could happen if KernelInfo.kernelArgInfo was accessible given a Kernel.  Just need an offset
 // into CrossThreadData.
-HWTEST_F(EnqueueFillBufferCmdTests, DISABLED_argumentOneShouldMatchOffset) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, DISABLED_argumentOneShouldMatchOffset) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

    enqueueFillBuffer<FamilyType>();
@@ -361,7 +361,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, DISABLED_argumentOneShouldMatchOffset) {
    context.getMemoryManager()->freeGraphicsMemory(patternAllocation);
 }

-HWTEST_F(EnqueueFillBufferCmdTests, argumentTwoShouldMatchPatternPtr) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillBufferCmdTests, argumentTwoShouldMatchPatternPtr) {
    auto patternAllocation = context.getMemoryManager()->allocateGraphicsMemory(EnqueueFillBufferTraits::patternSize, MemoryConstants::preferredAlignment);

    enqueueFillBuffer<FamilyType>();
@@ -395,7 +395,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, argumentTwoShouldMatchPatternPtr) {
 HWTEST_F(EnqueueFillBufferCmdTests, patternShouldBeCopied) {
    MemoryManager *mmgr = pCmdQ->getDevice().getMemoryManager();
    ASSERT_TRUE(mmgr->graphicsAllocations.peekIsEmpty());
-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    ASSERT_FALSE(mmgr->graphicsAllocations.peekIsEmpty());
    GraphicsAllocation *allocation = mmgr->graphicsAllocations.peekHead();

@@ -416,7 +416,7 @@ HWTEST_F(EnqueueFillBufferCmdTests, patternShouldBeCopied) {
 HWTEST_F(EnqueueFillBufferCmdTests, patternShouldBeAligned) {
    MemoryManager *mmgr = pCmdQ->getDevice().getMemoryManager();
    ASSERT_TRUE(mmgr->graphicsAllocations.peekIsEmpty());
-    enqueueFillBuffer<FamilyType>();
+    EnqueueFillBufferHelper<>::enqueueFillBuffer(pCmdQ, buffer);
    ASSERT_FALSE(mmgr->graphicsAllocations.peekIsEmpty());
    GraphicsAllocation *allocation = mmgr->graphicsAllocations.peekHead();

--- a/unit_tests/command_queue/enqueue_fill_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_fill_image_tests.cpp
@@ -46,12 +46,12 @@ HWTEST_F(EnqueueFillImageTest, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueFillImage<FamilyType>();
+    EnqueueFillImageHelper<>::enqueueFillImage(pCmdQ, image);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueFillImageTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueFillImage<FamilyType>();

@@ -85,14 +85,14 @@ HWTEST_F(EnqueueFillImageTest, gpgpuWalker) {
 HWTEST_F(EnqueueFillImageTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueFillImage<FamilyType>();
+    EnqueueFillImageHelper<>::enqueueFillImage(pCmdQ, image);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueFillImageTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueFillImage<FamilyType>();
+    EnqueueFillImageHelper<>::enqueueFillImage(pCmdQ, image);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -101,24 +101,24 @@ HWTEST_F(EnqueueFillImageTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueFillImage<FamilyType>();
+    EnqueueFillImageHelper<>::enqueueFillImage(pCmdQ, image);
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueFillImageTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, loadRegisterImmediateL3CNTLREG) {
    enqueueFillImage<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueFillImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueFillImage<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueFillImageTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -144,7 +144,7 @@ HWTEST_F(EnqueueFillImageTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueFillImageTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -171,7 +171,7 @@ HWTEST_F(EnqueueFillImageTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueFillImageTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueFillImage<FamilyType>();
@@ -189,13 +189,13 @@ HWTEST_F(EnqueueFillImageTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(image->getCpuAddress()), srcSurfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueFillImageTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, pipelineSelect) {
    enqueueFillImage<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueFillImageTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueFillImageTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueFillImage<FamilyType>();
--- a/unit_tests/command_queue/enqueue_kernel_tests.cpp
+++ b/unit_tests/command_queue/enqueue_kernel_tests.cpp
@@ -288,11 +288,9 @@ struct EnqueueKernelTypeTest : public HelloWorldFixture<HelloWorldFixtureFactory
        localWorkSize[1] = 1;
        localWorkSize[2] = 1;
    };
-    template <typename FamilyType>
-    void enqueueKernel(Kernel *inputKernel = nullptr) {
-        typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
-        typedef typename FamilyType::PIPELINE_SELECT PIPELINE_SELECT;

+    template <typename FamilyType, bool ParseCommands>
+    typename std::enable_if<false == ParseCommands, void>::type enqueueKernel(Kernel *inputKernel = nullptr) {
        cl_uint workDim = 1;
        size_t globalWorkOffset[3] = {0, 0, 0};

@@ -319,10 +317,20 @@ struct EnqueueKernelTypeTest : public HelloWorldFixture<HelloWorldFixtureFactory
            eventWaitList,
            event);
        ASSERT_EQ(CL_SUCCESS, retVal);
+    }
+
+    template <typename FamilyType, bool ParseCommands>
+    typename std::enable_if<ParseCommands, void>::type enqueueKernel(Kernel *inputKernel = nullptr) {
+        enqueueKernel<FamilyType, false>(inputKernel);

        parseCommands<FamilyType>(*pCmdQ);
    }

+    template <typename FamilyType>
+    void enqueueKernel(Kernel *inputKernel = nullptr) {
+        enqueueKernel<FamilyType, true>(inputKernel);
+    }
+
    void SetUp() override {
        ParentClass::SetUp();
        HardwareParse::SetUp();
@@ -349,7 +357,7 @@ void EnqueueKernelTypeTest<TestParam>::FillValues() {

 typedef EnqueueKernelTypeTest<TestParam> EnqueueWorkItemTests;

-HWTEST_P(EnqueueWorkItemTests, GPGPUWalker) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, GPGPUWalker) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::GPGPU_WALKER GPGPU_WALKER;

@@ -388,7 +396,7 @@ HWTEST_P(EnqueueWorkItemTests, GPGPUWalker) {
 HWTEST_P(EnqueueWorkItemTests, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueKernel<FamilyType>();
+    enqueueKernel<FamilyType, false>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

@@ -398,7 +406,7 @@ HWTEST_P(EnqueueWorkItemTests, alignsToCSR) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueKernel<FamilyType>();
+    enqueueKernel<FamilyType, false>();
    EXPECT_EQ(pCmdQ->taskCount, csr.peekTaskCount());
    EXPECT_EQ(pCmdQ->taskLevel + 1, csr.peekTaskLevel());
 }
@@ -406,7 +414,7 @@ HWTEST_P(EnqueueWorkItemTests, alignsToCSR) {
 HWTEST_P(EnqueueWorkItemTests, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueKernel<FamilyType>();
+    enqueueKernel<FamilyType, false>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -415,7 +423,7 @@ HWTEST_P(EnqueueWorkItemTests, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueKernel<FamilyType>();
+    enqueueKernel<FamilyType, false>();
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    if (pKernel->requiresSshForBuffers() || (pKernel->getKernelInfo().patchInfo.imageMemObjKernelArgs.size() > 0)) {
@@ -423,19 +431,19 @@ HWTEST_P(EnqueueWorkItemTests, addsIndirectData) {
    }
 }

-HWTEST_P(EnqueueWorkItemTests, LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, LoadRegisterImmediateL3CNTLREG) {
    enqueueKernel<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_P(EnqueueWorkItemTests, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueKernel<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList,
                                         context->getMemoryManager()->peekForce32BitAllocations() ? context->getMemoryManager()->allocator32Bit->getBase() : 0llu);
 }

-HWTEST_P(EnqueueWorkItemTests, MediaInterfaceDescriptorLoad) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename PARSE::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -463,7 +471,7 @@ HWTEST_P(EnqueueWorkItemTests, MediaInterfaceDescriptorLoad) {
    PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorCmd);
 }

-HWTEST_P(EnqueueWorkItemTests, InterfaceDescriptorData) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, InterfaceDescriptorData) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename PARSE::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
@@ -502,13 +510,13 @@ HWTEST_P(EnqueueWorkItemTests, InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_P(EnqueueWorkItemTests, PipelineSelect) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, PipelineSelect) {
    enqueueKernel<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_P(EnqueueWorkItemTests, MediaVFEState) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueWorkItemTests, MediaVFEState) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_VFE_STATE MEDIA_VFE_STATE;
    enqueueKernel<FamilyType>();
@@ -539,7 +547,7 @@ INSTANTIATE_TEST_CASE_P(EnqueueKernel,

 typedef EnqueueKernelTypeTest<TestParam2> EnqueueScratchSpaceTests;

-HWTEST_P(EnqueueScratchSpaceTests, GivenKernelRequiringScratchWhenItIsEnqueuedWithDifferentScratchSizesThenMediaVFEStateAndStateBaseAddressAreProperlyProgrammed) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueScratchSpaceTests, GivenKernelRequiringScratchWhenItIsEnqueuedWithDifferentScratchSizesThenMediaVFEStateAndStateBaseAddressAreProperlyProgrammed) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_VFE_STATE MEDIA_VFE_STATE;
    typedef typename PARSE::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
@@ -698,7 +706,7 @@ HWTEST_P(EnqueueKernelWithScratch, GivenKernelRequiringScratchWhenItIsEnqueuedWi
    auto valueToProgram = Kernel::getScratchSizeValueToProgramMediaVfeState(scratchSize);
    EXPECT_EQ(bitValue, valueToProgram);

-    enqueueKernel<FamilyType>(mockKernel);
+    enqueueKernel<FamilyType, false>(mockKernel);

    auto graphicsAllocation = mockCsr->getScratchAllocation();

@@ -708,12 +716,12 @@ HWTEST_P(EnqueueKernelWithScratch, GivenKernelRequiringScratchWhenItIsEnqueuedWi
    scratchSize = 8196;
    mediaVFEstate.PerThreadScratchSpace = scratchSize;

-    enqueueKernel<FamilyType>(mockKernel);
+    enqueueKernel<FamilyType, false>(mockKernel);

    EXPECT_TRUE(mockCsr->isMadeNonResident(graphicsAllocation));
 }

-HWTEST_P(EnqueueKernelWithScratch, givenDeviceForcing32bitAllocationsWhenKernelWithScratchIsEnqueuedThenGeneralStateHeapBaseAddressIsCorrectlyProgrammedAndMediaVFEStateContainsProgramming) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelWithScratch, givenDeviceForcing32bitAllocationsWhenKernelWithScratchIsEnqueuedThenGeneralStateHeapBaseAddressIsCorrectlyProgrammedAndMediaVFEStateContainsProgramming) {

    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_VFE_STATE MEDIA_VFE_STATE;
@@ -788,7 +796,7 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfThenPatchCrossTHreadData)
    mockKernel.crossThreadData[64] = 0;
    mockKernel.kernelInfo.patchInfo.pAllocateStatelessPrintfSurface = &patchData;

-    enqueueKernel<FamilyType>(mockKernel);
+    enqueueKernel<FamilyType, false>(mockKernel);

    EXPECT_EQ(mockKernel.crossThreadData[64], 0);
 }
@@ -805,13 +813,13 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWhenBeingDispatchedThenL3
    mockKernel.kernelInfo.patchInfo.pAllocateStatelessPrintfSurface = &patchData;
    auto &csr = pCmdQ->getDevice().getCommandStreamReceiver();
    auto latestSentTaskCount = csr.peekTaskCount();
-    enqueueKernel<FamilyType>(mockKernel);
+    enqueueKernel<FamilyType, false>(mockKernel);
    auto newLatestSentTaskCount = csr.peekTaskCount();
    EXPECT_GT(newLatestSentTaskCount, latestSentTaskCount);
    EXPECT_EQ(pCmdQ->latestTaskCountWaited, newLatestSentTaskCount);
 }

-HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUnblockedThenL3CacheIsFlushed) {
+HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUnblockedThenL3CacheIsFlushed) {
    typedef typename FamilyType::PARSE PARSE;

    UserEvent userEvent(context);
@@ -905,7 +913,6 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUn

        userEvent.setStatus(CL_COMPLETE);

-        parseCommands<FamilyType>(*pCmdQ);
        std::string output = testing::internal::GetCapturedStdout();
        EXPECT_STREQ("test", output.c_str());
    }
@@ -984,7 +991,7 @@ TEST_F(EnqueueKernelTest, GivenKernelWithBuiltinDispatchInfoBuilderWhenBeingDisp
    BuiltIns::shutDown();
 }

-HWTEST_F(EnqueueKernelTest, givenSecondEnqueueWithTheSameScratchRequirementWhenPreemptionIsEnabledThenDontProgramMVSAgain) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueKernelTest, givenSecondEnqueueWithTheSameScratchRequirementWhenPreemptionIsEnabledThenDontProgramMVSAgain) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;
    pDevice->setPreemptionMode(PreemptionMode::ThreadGroup);
    auto &csr = pDevice->getCommandStreamReceiver();
--- a/unit_tests/command_queue/enqueue_kernel_two_ioq_tests.cpp
+++ b/unit_tests/command_queue/enqueue_kernel_two_ioq_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -111,25 +111,25 @@ struct TwoIOQsTwoDependentWalkers : public HelloWorldTest<HelloWorldFixtureFacto
    CommandQueue *pCmdQ2 = nullptr;
 };

-HWTEST_F(TwoIOQsTwoDependentWalkers, shouldHaveTwoWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoIOQsTwoDependentWalkers, shouldHaveTwoWalkers) {
    parseWalkers<FamilyType>();
    EXPECT_NE(itorWalker1, itorWalker2);
 }

-HWTEST_F(TwoIOQsTwoDependentWalkers, shouldHaveOnePS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoIOQsTwoDependentWalkers, shouldHaveOnePS) {
    parseWalkers<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(TwoIOQsTwoDependentWalkers, shouldHaveOneVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoIOQsTwoDependentWalkers, shouldHaveOneVFEState) {
    parseWalkers<FamilyType>();

    auto numCommands = getCommandsList<typename FamilyType::MEDIA_VFE_STATE>().size();
    EXPECT_EQ(1u, numCommands);
 }

-HWTEST_F(TwoIOQsTwoDependentWalkers, shouldHaveAPipecontrolBetweenWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoIOQsTwoDependentWalkers, shouldHaveAPipecontrolBetweenWalkers) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    parseWalkers<FamilyType>();
--- a/unit_tests/command_queue/enqueue_kernel_two_ooq_tests.cpp
+++ b/unit_tests/command_queue/enqueue_kernel_two_ooq_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -118,25 +118,25 @@ struct TwoOOQsTwoDependentWalkers : public HelloWorldTest<OOQFixtureFactory>,
    CommandQueue *pCmdQ2 = nullptr;
 };

-HWTEST_F(TwoOOQsTwoDependentWalkers, shouldHaveTwoWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoOOQsTwoDependentWalkers, shouldHaveTwoWalkers) {
    parseWalkers<FamilyType>();
    EXPECT_NE(itorWalker1, itorWalker2);
 }

-HWTEST_F(TwoOOQsTwoDependentWalkers, shouldHaveOnePS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoOOQsTwoDependentWalkers, shouldHaveOnePS) {
    parseWalkers<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(TwoOOQsTwoDependentWalkers, shouldHaveOneVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoOOQsTwoDependentWalkers, shouldHaveOneVFEState) {
    parseWalkers<FamilyType>();

    auto numCommands = getCommandsList<typename FamilyType::MEDIA_VFE_STATE>().size();
    EXPECT_EQ(1u, numCommands);
 }

-HWTEST_F(TwoOOQsTwoDependentWalkers, shouldHaveAPipecontrolBetweenWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TwoOOQsTwoDependentWalkers, shouldHaveAPipecontrolBetweenWalkers) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    parseWalkers<FamilyType>();
--- a/unit_tests/command_queue/enqueue_kernel_two_walker_ioq_tests.cpp
+++ b/unit_tests/command_queue/enqueue_kernel_two_walker_ioq_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -28,26 +28,26 @@ using namespace OCLRT;

 typedef TwoWalkerTest<HelloWorldFixtureFactory> IOQWithTwoWalkers;

-HWTEST_F(IOQWithTwoWalkers, shouldHaveTwoWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, IOQWithTwoWalkers, shouldHaveTwoWalkers) {
    enqueueTwoKernels<FamilyType>();

    EXPECT_NE(itorWalker1, itorWalker2);
 }

-HWTEST_F(IOQWithTwoWalkers, shouldHaveOnePS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, IOQWithTwoWalkers, shouldHaveOnePS) {
    enqueueTwoKernels<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(IOQWithTwoWalkers, shouldHaveOneVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, IOQWithTwoWalkers, shouldHaveOneVFEState) {
    enqueueTwoKernels<FamilyType>();

    auto numCommands = getCommandsList<typename FamilyType::MEDIA_VFE_STATE>().size();
    EXPECT_EQ(1u, numCommands);
 }

-HWTEST_F(IOQWithTwoWalkers, shouldHaveAPipecontrolBetweenWalkers2) {
+HWCMDTEST_F(IGFX_GEN8_CORE, IOQWithTwoWalkers, shouldHaveAPipecontrolBetweenWalkers2) {
    enqueueTwoKernels<FamilyType>();
    auto &commandStreamReceiver = pDevice->getCommandStreamReceiver();

--- a/unit_tests/command_queue/enqueue_kernel_two_walker_ooq_tests.cpp
+++ b/unit_tests/command_queue/enqueue_kernel_two_walker_ooq_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -32,26 +32,26 @@ struct OOQFixtureFactory : public HelloWorldFixtureFactory {

 typedef TwoWalkerTest<OOQFixtureFactory> OOQWithTwoWalkers;

-HWTEST_F(OOQWithTwoWalkers, shouldHaveTwoWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, OOQWithTwoWalkers, shouldHaveTwoWalkers) {
    enqueueTwoKernels<FamilyType>();

    EXPECT_NE(itorWalker1, itorWalker2);
 }

-HWTEST_F(OOQWithTwoWalkers, shouldHaveOnePS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, OOQWithTwoWalkers, shouldHaveOnePS) {
    enqueueTwoKernels<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(OOQWithTwoWalkers, shouldHaveOneVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, OOQWithTwoWalkers, shouldHaveOneVFEState) {
    enqueueTwoKernels<FamilyType>();

    auto numCommands = getCommandsList<typename FamilyType::MEDIA_VFE_STATE>().size();
    EXPECT_EQ(1u, numCommands);
 }

-HWTEST_F(OOQWithTwoWalkers, shouldntHaveAPipecontrolBetweenWalkers) {
+HWCMDTEST_F(IGFX_GEN8_CORE, OOQWithTwoWalkers, shouldntHaveAPipecontrolBetweenWalkers) {
    enqueueTwoKernels<FamilyType>();

    auto itorCmd = find<typename FamilyType::PIPE_CONTROL *>(itorWalker1, itorWalker2);
--- a/unit_tests/command_queue/enqueue_map_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_map_image_tests.cpp
@@ -1000,7 +1000,7 @@ struct EnqueueMapImageTypeTest : public CommandEnqueueFixture,
    Image *image = nullptr;
 };

-HWTEST_F(EnqueueMapImageTypeTest, blockingEnqueueRequiresPCWithDCFlushSetAfterWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueMapImageTypeTest, blockingEnqueueRequiresPCWithDCFlushSetAfterWalker) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    // Set taskCount to 1 to call finish on map operation
--- a/unit_tests/command_queue/enqueue_marker_tests.cpp
+++ b/unit_tests/command_queue/enqueue_marker_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -43,7 +43,7 @@ struct MarkerFixture : public CommandEnqueueFixture {

 typedef Test<MarkerFixture> MarkerTest;

-HWTEST_F(MarkerTest, CS_EQ_CQ_ShouldntAddPipeControl) {
+HWCMDTEST_F(IGFX_GEN8_CORE, MarkerTest, CS_EQ_CQ_ShouldntAddPipeControl) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();

--- a/unit_tests/command_queue/enqueue_media_kernel.cpp
+++ b/unit_tests/command_queue/enqueue_media_kernel.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -32,13 +32,13 @@ TEST_F(MediaKernelTest, VmeKernelProperlyIdentifiesItself) {
    ASSERT_EQ(true, pVmeKernel->isVmeKernel());
 }

-HWTEST_F(MediaKernelTest, EnqueueVmeKernelUsesSinglePipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, MediaKernelTest, EnqueueVmeKernelUsesSinglePipelineSelect) {
    enqueueVmeKernel<FamilyType>();
    auto numCommands = getCommandsList<typename FamilyType::PIPELINE_SELECT>().size();
    EXPECT_EQ(1u, numCommands);
 }

-HWTEST_F(MediaKernelTest, EnqueueRegularKernelUsesSinglePipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, MediaKernelTest, EnqueueRegularKernelUsesSinglePipelineSelect) {
    enqueueRegularKernel<FamilyType>();
    auto numCommands = getCommandsList<typename FamilyType::PIPELINE_SELECT>().size();
    EXPECT_EQ(1u, numCommands);
--- a/unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp
+++ b/unit_tests/command_queue/enqueue_read_buffer_rect_tests.cpp
@@ -106,7 +106,7 @@ HWTEST_F(EnqueueReadBufferRectTest, returnSuccess) {
    EXPECT_EQ(CL_SUCCESS, retVal);
 }

-HWTEST_F(EnqueueReadBufferRectTest, alignsToCSR_Blocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, alignsToCSR_Blocking) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -118,7 +118,7 @@ HWTEST_F(EnqueueReadBufferRectTest, alignsToCSR_Blocking) {
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }

-HWTEST_F(EnqueueReadBufferRectTest, alignsToCSR_NonBlocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, alignsToCSR_NonBlocking) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -129,7 +129,7 @@ HWTEST_F(EnqueueReadBufferRectTest, alignsToCSR_NonBlocking) {
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueReadBufferRect2D<FamilyType>();

@@ -160,21 +160,21 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_GPGPUWalker) {
    }
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_bumpsTaskLevel) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    enqueueReadBufferRect2D<FamilyType>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_addsCommands) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    enqueueReadBufferRect2D<FamilyType>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_addsIndirectData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_addsIndirectData) {
    auto dshBefore = pDSH->getUsed();
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();
@@ -210,18 +210,18 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
    enqueueReadBufferRect2D<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueReadBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueReadBufferRect2D<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -249,7 +249,7 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -287,13 +287,13 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_PipelineSelect) {
    enqueueReadBufferRect2D<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueReadBufferRectTest, 2D_MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, 2D_MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueReadBufferRect2D<FamilyType>();
@@ -313,7 +313,7 @@ HWTEST_F(EnqueueReadBufferRectTest, 2D_MediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueReadBufferRectTest, blockingRequiresPipeControlAfterWalkerWithDCFlushSet) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferRectTest, blockingRequiresPipeControlAfterWalkerWithDCFlushSet) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    auto blocking = CL_TRUE;
--- a/unit_tests/command_queue/enqueue_read_buffer_tests.cpp
+++ b/unit_tests/command_queue/enqueue_read_buffer_tests.cpp
@@ -66,7 +66,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, null_user_pointer) {
    EXPECT_EQ(CL_INVALID_VALUE, retVal);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

    srcBuffer->forceDisallowCPUCopy = true;
@@ -107,7 +107,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueReadBuffer<FamilyType>();
+    EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

@@ -119,7 +119,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, alignsToCSR_Blocking) {
    auto oldCsrTaskLevel = csr.peekTaskLevel();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueReadBuffer<FamilyType>(CL_TRUE);
+    EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }
@@ -130,7 +130,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, alignsToCSR_NonBlocking) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueReadBuffer<FamilyType>(CL_FALSE);
+    EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_FALSE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -139,7 +139,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueReadBuffer<FamilyType>();
+    EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -149,7 +149,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsIndirectData) {
    auto sshBefore = pSSH->getUsed();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueReadBuffer<FamilyType>();
+    EnqueueReadBufferHelper<>::enqueueReadBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);

    MultiDispatchInfo multiDispatchInfo;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
@@ -173,20 +173,20 @@ HWTEST_F(EnqueueReadBufferTypeTest, addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueReadBufferTypeTest, LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, LoadRegisterImmediateL3CNTLREG) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueReadBuffer<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueReadBuffer<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -215,7 +215,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -254,14 +254,14 @@ HWTEST_F(EnqueueReadBufferTypeTest, InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueReadBufferTypeTest, PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, PipelineSelect) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueReadBuffer<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    srcBuffer->forceDisallowCPUCopy = true;
@@ -282,7 +282,7 @@ HWTEST_F(EnqueueReadBufferTypeTest, MediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueReadBufferTypeTest, blockingRequiresPipeControlAfterWalkerWithDCFlushSet) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadBufferTypeTest, blockingRequiresPipeControlAfterWalkerWithDCFlushSet) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    srcBuffer->forceDisallowCPUCopy = true;
--- a/unit_tests/command_queue/enqueue_read_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_read_image_tests.cpp
@@ -29,7 +29,7 @@

 using namespace OCLRT;

-HWTEST_F(EnqueueReadImageTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueReadImage<FamilyType>();

@@ -67,7 +67,7 @@ HWTEST_F(EnqueueReadImageTest, alignsToCSR_Blocking) {
    csr.taskLevel = pCmdQ->taskLevel + 50;
    auto oldCsrTaskLevel = csr.peekTaskLevel();

-    enqueueReadImage<FamilyType>(CL_TRUE);
+    EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, CL_TRUE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }
@@ -78,7 +78,7 @@ HWTEST_F(EnqueueReadImageTest, alignsToCSR_NonBlocking) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueReadImage<FamilyType>(CL_FALSE);
+    EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, CL_FALSE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -86,14 +86,14 @@ HWTEST_F(EnqueueReadImageTest, alignsToCSR_NonBlocking) {
 HWTEST_F(EnqueueReadImageTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueReadImage<FamilyType>();
+    EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, EnqueueReadImageTraits::blocking);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueReadImageTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueReadImage<FamilyType>();
+    EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, EnqueueReadImageTraits::blocking);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -102,24 +102,24 @@ HWTEST_F(EnqueueReadImageTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueReadImage<FamilyType>();
+    EnqueueReadImageHelper<>::enqueueReadImage(pCmdQ, srcImage, EnqueueReadImageTraits::blocking);
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueReadImageTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, loadRegisterImmediateL3CNTLREG) {
    enqueueReadImage<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueReadImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueReadImage<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueReadImageTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -145,7 +145,7 @@ HWTEST_F(EnqueueReadImageTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueReadImageTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -170,7 +170,7 @@ HWTEST_F(EnqueueReadImageTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueReadImageTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueReadImage<FamilyType>();
@@ -191,13 +191,13 @@ HWTEST_F(EnqueueReadImageTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(srcImage->getCpuAddress()), surfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueReadImageTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, pipelineSelect) {
    enqueueReadImage<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueReadImageTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueReadImage<FamilyType>();
@@ -213,7 +213,7 @@ HWTEST_F(EnqueueReadImageTest, mediaVFEState) {
    FamilyType::PARSE::template validateCommand<MEDIA_VFE_STATE *>(cmdList.begin(), itorMediaVfeState);
 }

-HWTEST_F(EnqueueReadImageTest, blockingEnqueueRequiresPCWithDCFlushSetAfterWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueReadImageTest, blockingEnqueueRequiresPCWithDCFlushSetAfterWalker) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    bool blocking = true;
--- a/unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp
+++ b/unit_tests/command_queue/enqueue_write_buffer_rect_tests.cpp
@@ -81,7 +81,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, returnSuccess) {
    EXPECT_EQ(CL_SUCCESS, retVal);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, alignsToCSR_Blocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, alignsToCSR_Blocking) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -93,7 +93,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, alignsToCSR_Blocking) {
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, alignsToCSR_NonBlocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, alignsToCSR_NonBlocking) {
    //this test case assumes IOQ
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.taskCount = pCmdQ->taskCount + 100;
@@ -104,7 +104,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, alignsToCSR_NonBlocking) {
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueWriteBufferRect2D<FamilyType>();

@@ -135,21 +135,21 @@ HWTEST_F(EnqueueWriteBufferRectTest, 2D_GPGPUWalker) {
    }
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_bumpsTaskLevel) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    enqueueWriteBufferRect2D<FamilyType>();
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_addsCommands) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    enqueueWriteBufferRect2D<FamilyType>();
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_addsIndirectData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_addsIndirectData) {
    auto dshBefore = pDSH->getUsed();
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();
@@ -184,18 +184,18 @@ HWTEST_F(EnqueueWriteBufferRectTest, 2D_addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_LoadRegisterImmediateL3CNTLREG) {
    enqueueWriteBufferRect2D<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, When2DEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueWriteBufferRect2D<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -223,7 +223,7 @@ HWTEST_F(EnqueueWriteBufferRectTest, 2D_MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -261,13 +261,13 @@ HWTEST_F(EnqueueWriteBufferRectTest, 2D_InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_PipelineSelect) {
    enqueueWriteBufferRect2D<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueWriteBufferRectTest, 2D_MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferRectTest, 2D_MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueWriteBufferRect2D<FamilyType>();
--- a/unit_tests/command_queue/enqueue_write_buffer_tests.cpp
+++ b/unit_tests/command_queue/enqueue_write_buffer_tests.cpp
@@ -73,7 +73,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, alignsToCSR_Blocking) {
    auto oldCsrTaskLevel = csr.peekTaskLevel();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueWriteBuffer<FamilyType>(CL_TRUE);
+    EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), CL_TRUE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }
@@ -84,12 +84,12 @@ HWTEST_F(EnqueueWriteBufferTypeTest, alignsToCSR_NonBlocking) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueWriteBuffer<FamilyType>(CL_FALSE);
+    EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), CL_FALSE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, GPGPUWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, GPGPUWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

    srcBuffer->forceDisallowCPUCopy = true;
@@ -126,7 +126,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueWriteBuffer<FamilyType>();
+    EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), EnqueueWriteBufferTraits::blocking);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

@@ -134,7 +134,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueWriteBuffer<FamilyType>();
+    EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), EnqueueWriteBufferTraits::blocking);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -144,7 +144,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, addsIndirectData) {
    auto sshBefore = pSSH->getUsed();

    srcBuffer->forceDisallowCPUCopy = true;
-    enqueueWriteBuffer<FamilyType>();
+    EnqueueWriteBufferHelper<>::enqueueWriteBuffer(pCmdQ, srcBuffer.get(), EnqueueWriteBufferTraits::blocking);

    MultiDispatchInfo multiDispatchInfo;
    auto &builder = BuiltIns::getInstance().getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyBufferToBuffer,
@@ -168,13 +168,13 @@ HWTEST_F(EnqueueWriteBufferTypeTest, addsIndirectData) {
    }
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, LoadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, LoadRegisterImmediateL3CNTLREG) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueWriteBuffer<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueWriteBuffer<FamilyType>();

@@ -182,7 +182,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, WhenEnqueueIsDoneThenStateBaseAddressIsProp
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, MediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, MediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -211,7 +211,7 @@ HWTEST_F(EnqueueWriteBufferTypeTest, MediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorCmd);
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, InterfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, InterfaceDescriptorData) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -250,14 +250,14 @@ HWTEST_F(EnqueueWriteBufferTypeTest, InterfaceDescriptorData) {
    EXPECT_NE(0u, IDD.getConstantIndirectUrbEntryReadLength());
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, PipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, PipelineSelect) {
    srcBuffer->forceDisallowCPUCopy = true;
    enqueueWriteBuffer<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueWriteBufferTypeTest, MediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteBufferTypeTest, MediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    srcBuffer->forceDisallowCPUCopy = true;
--- a/unit_tests/command_queue/enqueue_write_image_tests.cpp
+++ b/unit_tests/command_queue/enqueue_write_image_tests.cpp
@@ -30,7 +30,7 @@

 using namespace OCLRT;

-HWTEST_F(EnqueueWriteImageTest, gpgpuWalker) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, gpgpuWalker) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    enqueueWriteImage<FamilyType>();

@@ -68,7 +68,7 @@ HWTEST_F(EnqueueWriteImageTest, alignsToCSR_Blocking) {
    csr.taskLevel = pCmdQ->taskLevel + 50;
    auto oldCsrTaskLevel = csr.peekTaskLevel();

-    enqueueWriteImage<FamilyType>(CL_TRUE);
+    EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, dstImage, CL_TRUE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(oldCsrTaskLevel, pCmdQ->taskLevel);
 }
@@ -79,7 +79,7 @@ HWTEST_F(EnqueueWriteImageTest, alignsToCSR_NonBlocking) {
    csr.taskCount = pCmdQ->taskCount + 100;
    csr.taskLevel = pCmdQ->taskLevel + 50;

-    enqueueWriteImage<FamilyType>(CL_FALSE);
+    EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, dstImage, CL_FALSE);
    EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
    EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
 }
@@ -87,14 +87,14 @@ HWTEST_F(EnqueueWriteImageTest, alignsToCSR_NonBlocking) {
 HWTEST_F(EnqueueWriteImageTest, bumpsTaskLevel) {
    auto taskLevelBefore = pCmdQ->taskLevel;

-    enqueueWriteImage<FamilyType>();
+    EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, dstImage, EnqueueWriteImageTraits::blocking);
    EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
 }

 HWTEST_F(EnqueueWriteImageTest, addsCommands) {
    auto usedCmdBufferBefore = pCS->getUsed();

-    enqueueWriteImage<FamilyType>();
+    EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, dstImage, EnqueueWriteImageTraits::blocking);
    EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
 }

@@ -103,24 +103,24 @@ HWTEST_F(EnqueueWriteImageTest, addsIndirectData) {
    auto iohBefore = pIOH->getUsed();
    auto sshBefore = pSSH->getUsed();

-    enqueueWriteImage<FamilyType>();
+    EnqueueWriteImageHelper<>::enqueueWriteImage(pCmdQ, dstImage, EnqueueWriteImageTraits::blocking);
    EXPECT_NE(dshBefore, pDSH->getUsed());
    EXPECT_NE(iohBefore, pIOH->getUsed());
    EXPECT_NE(sshBefore, pSSH->getUsed());
 }

-HWTEST_F(EnqueueWriteImageTest, loadRegisterImmediateL3CNTLREG) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, loadRegisterImmediateL3CNTLREG) {
    enqueueWriteImage<FamilyType>();
    validateL3Programming<FamilyType>(cmdList, itorWalker);
 }

-HWTEST_F(EnqueueWriteImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
    enqueueWriteImage<FamilyType>();
    validateStateBaseAddress<FamilyType>(this->pDevice->getCommandStreamReceiver().getMemoryManager()->getInternalHeapBaseAddress(),
                                         pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
 }

-HWTEST_F(EnqueueWriteImageTest, mediaInterfaceDescriptorLoad) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, mediaInterfaceDescriptorLoad) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -146,7 +146,7 @@ HWTEST_F(EnqueueWriteImageTest, mediaInterfaceDescriptorLoad) {
    FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
 }

-HWTEST_F(EnqueueWriteImageTest, interfaceDescriptorData) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, interfaceDescriptorData) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

@@ -172,7 +172,7 @@ HWTEST_F(EnqueueWriteImageTest, interfaceDescriptorData) {
    EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
 }

-HWTEST_F(EnqueueWriteImageTest, surfaceState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, surfaceState) {
    typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;

    enqueueWriteImage<FamilyType>();
@@ -193,13 +193,13 @@ HWTEST_F(EnqueueWriteImageTest, surfaceState) {
    EXPECT_EQ(reinterpret_cast<uint64_t>(dstImage->getCpuAddress()), surfaceState.getSurfaceBaseAddress());
 }

-HWTEST_F(EnqueueWriteImageTest, pipelineSelect) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, pipelineSelect) {
    enqueueWriteImage<FamilyType>();
    int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
    EXPECT_EQ(1, numCommands);
 }

-HWTEST_F(EnqueueWriteImageTest, mediaVFEState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueWriteImageTest, mediaVFEState) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;

    enqueueWriteImage<FamilyType>();
--- a/unit_tests/command_queue/get_size_required_buffer_tests.cpp
+++ b/unit_tests/command_queue/get_size_required_buffer_tests.cpp
@@ -76,7 +76,7 @@ struct GetSizeRequiredBufferTest : public CommandEnqueueFixture,
    GraphicsAllocation *patternAllocation = nullptr;
 };

-HWTEST_F(GetSizeRequiredBufferTest, enqueueFillBuffer) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueFillBuffer) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    auto &commandStream = pCmdQ->getCS();
    auto usedBeforeCS = commandStream.getUsed();
@@ -128,7 +128,7 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueFillBuffer) {
    EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
 }

-HWTEST_F(GetSizeRequiredBufferTest, enqueueCopyBuffer) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueCopyBuffer) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    auto &commandStream = pCmdQ->getCS();
    auto usedBeforeCS = commandStream.getUsed();
@@ -179,7 +179,7 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueCopyBuffer) {
    EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
 }

-HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    auto &commandStream = pCmdQ->getCS();
    auto usedBeforeCS = commandStream.getUsed();
@@ -231,7 +231,7 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferNonBlocking) {
    EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
 }

-HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    auto &commandStream = pCmdQ->getCS();
    auto usedBeforeCS = commandStream.getUsed();
@@ -284,7 +284,7 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueReadBufferBlocking) {
    EXPECT_GE(expectedSizeSSH, usedAfterSSH - usedBeforeSSH);
 }

-HWTEST_F(GetSizeRequiredBufferTest, enqueueWriteBufferNonBlocking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueWriteBufferNonBlocking) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    auto &commandStream = pCmdQ->getCS();
    auto usedBeforeCS = commandStream.getUsed();
@@ -422,7 +422,7 @@ HWTEST_F(GetSizeRequiredBufferTest, enqueueKernelHelloWorld) {
    EXPECT_GE(expectedSizeSSH, sshAfter - sshBefore);
 }

-HWTEST_F(GetSizeRequiredBufferTest, enqueueKernelSimpleArg) {
+HWCMDTEST_F(IGFX_GEN8_CORE, GetSizeRequiredBufferTest, enqueueKernelSimpleArg) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    typedef SimpleArgKernelFixture KernelFixture;
    auto &commandStream = pCmdQ->getCS();
--- a/unit_tests/command_queue/work_group_size_tests.cpp
+++ b/unit_tests/command_queue/work_group_size_tests.cpp
@@ -141,7 +141,7 @@ struct WorkGroupSizeChannels : public WorkGroupSizeBase,
    }
 };

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDefault) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDefault) {
    uint32_t simdSize;
    size_t workDim;
    std::tie(simdSize, workDim) = GetParam();
@@ -149,7 +149,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDefault) {
    verify<FamilyType>(simdSize, workDim, workDim, workDim);
 }

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDEnabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDEnabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(true);
    uint32_t simdSize;
@@ -161,7 +161,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDEnabled) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDisabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDisabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
    uint32_t simdSize;
@@ -173,7 +173,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeNDDisabled)
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDefault) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDefault) {
    uint32_t simdSize;
    size_t workDim;
    std::tie(simdSize, workDim) = GetParam();
@@ -181,7 +181,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDefau
    verify<FamilyType>(simdSize, workDim, workDim, workDim);
 }

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredEnabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredEnabled) {
    DebugManagerStateRestore dbgRestore;
    DebugManager.flags.EnableComputeWorkSizeSquared.set(true);
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
@@ -192,7 +192,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredEnabl
    verify<FamilyType>(simdSize, workDim, workDim, workDim);
 }

-HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDisabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDisabled) {
    DebugManagerStateRestore dbgRestore;
    DebugManager.flags.EnableComputeWorkSizeSquared.set(false);
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
@@ -203,7 +203,7 @@ HWTEST_P(WorkGroupSizeChannels, allChannelsWithEnableComputeWorkSizeSquaredDisab
    verify<FamilyType>(simdSize, workDim, workDim, workDim);
 }

-HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDefault) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDefault) {
    uint32_t simdSize;
    size_t workDim;
    std::tie(simdSize, workDim) = GetParam();
@@ -211,7 +211,7 @@ HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDefault) {
    verify<FamilyType>(simdSize, workDim, 1, 1);
 }

-HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDEnabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDEnabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(true);
    uint32_t simdSize;
@@ -223,7 +223,7 @@ HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDEnabled) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDisabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDisabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
    uint32_t simdSize;
@@ -235,7 +235,7 @@ HWTEST_P(WorkGroupSizeChannels, justXWithEnableComputeWorkSizeNDDisabled) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDefault) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDefault) {
    uint32_t simdSize;
    size_t workDim;
    std::tie(simdSize, workDim) = GetParam();
@@ -243,7 +243,7 @@ HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDefault) {
    verify<FamilyType>(simdSize, 1, workDim, 1);
 }

-HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDEnalbed) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDEnalbed) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(true);
    uint32_t simdSize;
@@ -255,7 +255,7 @@ HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDEnalbed) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDisabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDisabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
    uint32_t simdSize;
@@ -267,7 +267,7 @@ HWTEST_P(WorkGroupSizeChannels, justYWithEnableComputeWorkSizeNDDisabled) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDDefault) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDDefault) {
    uint32_t simdSize;
    size_t workDim;
    std::tie(simdSize, workDim) = GetParam();
@@ -275,7 +275,7 @@ HWTEST_P(WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDDefault) {
    verify<FamilyType>(simdSize, 1, 1, workDim);
 }

-HWTEST_P(WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDEnabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDEnabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(true);
    uint32_t simdSize;
@@ -287,7 +287,7 @@ HWTEST_P(WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDEnabled) {
    DebugManager.flags.EnableComputeWorkSizeND.set(isWorkGroupSizeEnabled);
 }

-HWTEST_P(WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDDisabled) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeChannels, justZWithEnableComputeWorkSizeNDDisabled) {
    bool isWorkGroupSizeEnabled = DebugManager.flags.EnableComputeWorkSizeND.get();
    DebugManager.flags.EnableComputeWorkSizeND.set(false);
    uint32_t simdSize;
@@ -339,7 +339,7 @@ struct WorkGroupSize2D : public WorkGroupSizeBase,
    }
 };

-HWTEST_P(WorkGroupSize2D, XY) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSize2D, XY) {
    uint32_t simdSize;
    size_t dimX, dimY;
    std::tie(simdSize, dimX, dimY) = GetParam();
@@ -372,7 +372,7 @@ struct WorkGroupSizeRegion : public WorkGroupSizeBase,
    }
 };

-HWTEST_P(WorkGroupSizeRegion, allChannels) {
+HWCMDTEST_P(IGFX_GEN8_CORE, WorkGroupSizeRegion, allChannels) {
    uint32_t simdSize;
    Region region;
    std::tie(simdSize, region) = GetParam();
--- a/unit_tests/command_stream/cmd_parse_tests.cpp
+++ b/unit_tests/command_stream/cmd_parse_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -59,7 +59,7 @@ HWTEST_F(CommandParse, getCommandLengthWithGarbage) {
    EXPECT_EQ(0u, PARSE::getCommandLength(&buffer));
 }

-HWTEST_F(CommandParse, parseCommandBufferWithLength) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandParse, parseCommandBufferWithLength) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    GenCmdList cmds;
--- a/unit_tests/command_stream/command_stream_receiver_hw_tests.cpp
+++ b/unit_tests/command_stream/command_stream_receiver_hw_tests.cpp
@@ -60,7 +60,7 @@ using namespace OCLRT;
 using ::testing::_;
 using ::testing::Invoke;

-HWTEST_F(UltCommandStreamReceiverTest, givenPreambleSentAndThreadArbitrationPolicyNotChangedWhenEstimatingPreambleCmdSizeThenReturnItsValue) {
+HWCMDTEST_F(IGFX_GEN8_CORE, UltCommandStreamReceiverTest, givenPreambleSentAndThreadArbitrationPolicyNotChangedWhenEstimatingPreambleCmdSizeThenReturnItsValue) {
    auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
    commandStreamReceiver.isPreambleSent = true;
    commandStreamReceiver.requiredThreadArbitrationPolicy = commandStreamReceiver.lastSentThreadArbitrationPolicy;
@@ -98,7 +98,7 @@ HWTEST_F(UltCommandStreamReceiverTest, givenPreambleSentWhenEstimatingPreambleCm
    EXPECT_EQ(expectedDifference, actualDifference);
 }

-HWTEST_F(UltCommandStreamReceiverTest, givenMediaVfeStateDirtyEstimatingPreambleCmdSizeThenResultDependsVfeStateProgrammingCmdSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, UltCommandStreamReceiverTest, givenMediaVfeStateDirtyEstimatingPreambleCmdSizeThenResultDependsVfeStateProgrammingCmdSize) {
    typedef typename FamilyType::MEDIA_VFE_STATE MEDIA_VFE_STATE;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

@@ -502,7 +502,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, stateBaseAddressTracking) {
    EXPECT_FALSE(commandStreamReceiver.sshState.updateAndCheck(&ssh));
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, stateBaseAddressProgrammingShouldMatchTracking) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, stateBaseAddressProgrammingShouldMatchTracking) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    auto stateHeapMocs = Gmm::getMOCS(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER);
    auto l3CacheOnMocs = Gmm::getMOCS(CacheSettings::l3CacheOn);
@@ -1233,7 +1233,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenDcFlush) {
    EXPECT_EQ(retVal, CL_SUCCESS);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenPowerOfTwoGlobalWorkSizeAndNullLocalWorkgroupSizeWhenEnqueueKernelIsCalledThenGpGpuWalkerHasOptimalSIMDmask) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenPowerOfTwoGlobalWorkSizeAndNullLocalWorkgroupSizeWhenEnqueueKernelIsCalledThenGpGpuWalkerHasOptimalSIMDmask) {
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    MockContext ctx(pDevice);
    MockKernelWithInternals kernel(*pDevice);
@@ -1326,7 +1326,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenNonBlockingMapWhenFinishIsCal
    ASSERT_EQ(cmdList.end(), itorPC);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenFlushedCallRequiringDCFlushWhenBlockingEnqueueIsCalledThenPipeControlWithDCFlushIsAdded) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, GivenFlushedCallRequiringDCFlushWhenBlockingEnqueueIsCalledThenPipeControlWithDCFlushIsAdded) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;

    MockContext ctx(pDevice);
@@ -1478,7 +1478,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, handleTagAndScratchAllocationsResi
    EXPECT_TRUE(commandStreamReceiver->isMadeNonResident(scratchAllocation));
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenTwoConsecutiveNDRangeKernelsStateBaseAddressIsProgrammedOnceAndScratchAddressInMediaVFEStateIsProgrammedTwiceBothWithCorrectAddress) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenTwoConsecutiveNDRangeKernelsStateBaseAddressIsProgrammedOnceAndScratchAddressInMediaVFEStateIsProgrammedTwiceBothWithCorrectAddress) {
    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_VFE_STATE MEDIA_VFE_STATE;
    typedef typename PARSE::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
@@ -1587,7 +1587,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenTwoConsecutiveNDRangeKernelsS
    }
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNDRangeKernelAndReadBufferStateBaseAddressAndScratchAddressInMediaVFEStateIsProgrammedForNDRangeAndReprogramedForReadBufferAndGSBAFlagIsResetToFalse) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenNDRangeKernelAndReadBufferStateBaseAddressAndScratchAddressInMediaVFEStateIsProgrammedForNDRangeAndReprogramedForReadBufferAndGSBAFlagIsResetToFalse) {

    typedef typename FamilyType::PARSE PARSE;
    typedef typename PARSE::MEDIA_VFE_STATE MEDIA_VFE_STATE;
@@ -1806,7 +1806,7 @@ HWTEST_F(UltCommandStreamReceiverTest, addPipeControlWithFlushAllCaches) {
    EXPECT_TRUE(pipeControl->getStateCacheInvalidationEnable());
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenEnabledPreemptionWhenFlushTaskCalledThenDontProgramMediaVfeStateAgain) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenEnabledPreemptionWhenFlushTaskCalledThenDontProgramMediaVfeStateAgain) {
    pDevice->setPreemptionMode(PreemptionMode::ThreadGroup);
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    HardwareParse hwParser;
@@ -1828,7 +1828,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenEnabledPreemptionWhenFlushTas
    EXPECT_EQ(nullptr, cmd);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, flushTaskWithPCWhenPreambleSentAndL3ConfigChanged) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, flushTaskWithPCWhenPreambleSentAndL3ConfigChanged) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
    typedef typename FamilyType::MI_BATCH_BUFFER_START MI_BATCH_BUFFER_START;
@@ -2757,7 +2757,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTotalRes
    EXPECT_TRUE(mockedSubmissionsAggregator->peekCommandBuffers().peekIsEmpty());
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTwoTasksArePassedWithTheSameLevelThenThereIsNoPipeControlBetweenThemAfterFlush) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTwoTasksArePassedWithTheSameLevelThenThereIsNoPipeControlBetweenThemAfterFlush) {
    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
    auto &commandStream = commandQueue.getCS(4096u);

@@ -2953,7 +2953,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenDcFlushI
    EXPECT_NE(nullptr, cmdBuffer->epiloguePipeControlLocation);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndOoqFlagSetToFalseWhenTwoTasksArePassedWithTheSameLevelThenThereIsPipeControlBetweenThemAfterFlush) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndOoqFlagSetToFalseWhenTwoTasksArePassedWithTheSameLevelThenThereIsPipeControlBetweenThemAfterFlush) {
    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
    auto &commandStream = commandQueue.getCS(4096u);

@@ -3009,7 +3009,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndOoqFlagSe
    EXPECT_NE(itorPipeControl, itorBatchBufferStartSecond);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenPipeControlForNoopAddressIsNullThenPipeControlIsNotNooped) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenPipeControlForNoopAddressIsNullThenPipeControlIsNotNooped) {
    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
    auto &commandStream = commandQueue.getCS(4096u);

@@ -3068,7 +3068,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenPipeCont
    EXPECT_NE(itorPipeControl, itorBatchBufferStartSecond);
 }

-HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenThreeTasksArePassedWithTheSameLevelThenThereIsNoPipeControlBetweenThemAfterFlush) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenThreeTasksArePassedWithTheSameLevelThenThereIsNoPipeControlBetweenThemAfterFlush) {
    CommandQueueHw<FamilyType> commandQueue(nullptr, pDevice, 0);
    auto &commandStream = commandQueue.getCS(4096u);

@@ -3337,7 +3337,9 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenMockCommandStreamerWhenAddPat
    dispatchFlags.throttle = QueueThrottle::MEDIUM;

    std::vector<PatchInfoData> patchInfoDataVector;
-    EXPECT_CALL(*mockHelper, setPatchInfoData(_)).Times(4).WillRepeatedly(Invoke([&](const PatchInfoData &data) {
+    EXPECT_CALL(*mockHelper, setPatchInfoData(_))
+        .Times(4)
+        .WillRepeatedly(Invoke([&](const PatchInfoData &data) {
            patchInfoDataVector.push_back(data);
            return true;
        }));
@@ -3381,11 +3383,14 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenMockCsrWhenCollectStateBaseAd
    mockCsr->overwriteFlatBatchBufferHelper(mockHelper);

    std::vector<PatchInfoData> patchInfoDataVector;
-    EXPECT_CALL(*mockHelper, setPatchInfoData(_)).Times(4).WillRepeatedly(Invoke([&](const PatchInfoData &data) {
+    EXPECT_CALL(*mockHelper, setPatchInfoData(_))
+        .Times(4)
+        .WillRepeatedly(Invoke([&](const PatchInfoData &data) {
            patchInfoDataVector.push_back(data);
            return true;
        }));
-    EXPECT_CALL(*mockHelper, registerCommandChunk(_)).Times(0);
+    EXPECT_CALL(*mockHelper, registerCommandChunk(_))
+        .Times(0);

    uint64_t baseAddress = 0xabcdef;
    uint64_t commandOffset = 0xa;
--- a/unit_tests/device_queue/device_queue_hw_tests.cpp
+++ b/unit_tests/device_queue/device_queue_hw_tests.cpp
@@ -96,7 +96,7 @@ HWTEST_F(DeviceQueueHwTest, acquireEMCriticalSectionDoesNotAcquireWhenNullHardwa
    delete deviceQueue;
 }

-HWTEST_F(DeviceQueueHwTest, getCSPrefetchSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueHwTest, getCSPrefetchSize) {
    auto mockDeviceQueueHw = new MockDeviceQueueHw<FamilyType>(pContext, device,
                                                               deviceQueueProperties::minimumProperties[0]);

@@ -104,7 +104,7 @@ HWTEST_F(DeviceQueueHwTest, getCSPrefetchSize) {
    delete mockDeviceQueueHw;
 }

-HWTEST_F(DeviceQueueHwTest, addLriWithArbCheck) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueHwTest, addLriWithArbCheck) {
    using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
    auto mockDeviceQueueHw = new MockDeviceQueueHw<FamilyType>(pContext, device,
                                                               deviceQueueProperties::minimumProperties[0]);
@@ -128,7 +128,7 @@ HWTEST_F(DeviceQueueHwTest, addLriWithArbCheck) {
    delete mockDeviceQueueHw;
 }

-HWTEST_F(DeviceQueueHwTest, addLriWithoutArbCheck) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueHwTest, addLriWithoutArbCheck) {
    using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
    auto mockDeviceQueueHw = new MockDeviceQueueHw<FamilyType>(pContext, device,
                                                               deviceQueueProperties::minimumProperties[0]);
@@ -165,7 +165,7 @@ class DeviceQueueSlb : public DeviceQueueHwTest {
    }
 };

-HWTEST_F(DeviceQueueSlb, allocateSlbBufferAllocatesCorrectSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, allocateSlbBufferAllocatesCorrectSize) {
    std::unique_ptr<MockDeviceQueueHw<FamilyType>> mockDeviceQueueHw(new MockDeviceQueueHw<FamilyType>(pContext, device, deviceQueueProperties::minimumProperties[0]));

    LinearStream *slbCS = mockDeviceQueueHw->getSlbCS();
@@ -179,7 +179,7 @@ HWTEST_F(DeviceQueueSlb, allocateSlbBufferAllocatesCorrectSize) {
    EXPECT_LE(expectedSize, slbCS->getAvailableSpace());
 }

-HWTEST_F(DeviceQueueSlb, buildSlbAfterReset) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, buildSlbAfterReset) {
    auto mockDeviceQueueHw =
        new MockDeviceQueueHw<FamilyType>(pContext, device, deviceQueueProperties::minimumProperties[0]);
    auto mockDeviceQueueHwWithProfiling =
@@ -263,7 +263,7 @@ HWTEST_F(DeviceQueueSlb, buildSlbAfterReset) {
    delete mockDeviceQueueHwWithProfiling;
 }

-HWTEST_F(DeviceQueueSlb, slbEndOffset) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, slbEndOffset) {
    auto mockDeviceQueueHw = new MockDeviceQueueHw<FamilyType>(pContext, device,
                                                               deviceQueueProperties::minimumProperties[0]);

@@ -302,7 +302,7 @@ HWTEST_F(DeviceQueueSlb, slbEndOffset) {
    free(slbCopy);
 }

-HWTEST_F(DeviceQueueSlb, cleanupSection) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, cleanupSection) {
    using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
    using MI_BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
@@ -354,7 +354,7 @@ HWTEST_F(DeviceQueueSlb, cleanupSection) {
    delete mockDeviceQueueHw;
 }

-HWTEST_F(DeviceQueueSlb, AddEMCleanupSectionWithProfiling) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueSlb, AddEMCleanupSectionWithProfiling) {
    using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
    using MI_BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
@@ -574,7 +574,7 @@ HWTEST_P(DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectStartBlockID) {
    }
 }

-HWTEST_P(DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectDSHValues) {
+HWCMDTEST_P(IGFX_GEN8_CORE, DeviceQueueHwWithKernel, setupIndirectStateSetsCorrectDSHValues) {
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;

    if (std::string(pPlatform->getDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {
@@ -619,7 +619,7 @@ INSTANTIATE_TEST_CASE_P(DeviceQueueHwWithKernel,

 typedef testing::Test TheSimplestDeviceQueueFixture;

-HWTEST_F(TheSimplestDeviceQueueFixture, resetDeviceQueueSetEarlyReturnValues) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, resetDeviceQueueSetEarlyReturnValues) {

    DebugManagerStateRestore dbgRestorer;

@@ -635,7 +635,7 @@ HWTEST_F(TheSimplestDeviceQueueFixture, resetDeviceQueueSetEarlyReturnValues) {
    EXPECT_EQ(0u, mockDeviceQueueHw->getIgilQueue()->m_controls.m_SchedulerEarlyReturnCounter);
 }

-HWTEST_F(TheSimplestDeviceQueueFixture, addMediaStateClearCmds) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, addMediaStateClearCmds) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE;

@@ -667,7 +667,7 @@ HWTEST_F(TheSimplestDeviceQueueFixture, addMediaStateClearCmds) {
    EXPECT_NE(hwParser.cmdList.end(), mediaVfeStateItor);
 }

-HWTEST_F(TheSimplestDeviceQueueFixture, addExecutionModelCleanupSectionClearsMediaState) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, addExecutionModelCleanupSectionClearsMediaState) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE;

@@ -696,7 +696,7 @@ HWTEST_F(TheSimplestDeviceQueueFixture, addExecutionModelCleanupSectionClearsMed
    EXPECT_TRUE(mockDeviceQueueHw->addMediaStateClearCmdsCalled);
 }

-HWTEST_F(TheSimplestDeviceQueueFixture, getMediaStateClearCmdsSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, getMediaStateClearCmdsSize) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    using MEDIA_VFE_STATE = typename FamilyType::MEDIA_VFE_STATE;

@@ -708,7 +708,7 @@ HWTEST_F(TheSimplestDeviceQueueFixture, getMediaStateClearCmdsSize) {
    EXPECT_EQ(expectedSize, MockDeviceQueueHw<FamilyType>::getMediaStateClearCmdsSize());
 }

-HWTEST_F(TheSimplestDeviceQueueFixture, getExecutionModelCleanupSectionSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, getExecutionModelCleanupSectionSize) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    using MI_MATH_ALU_INST_INLINE = typename FamilyType::MI_MATH_ALU_INST_INLINE;
    using MI_LOAD_REGISTER_REG = typename FamilyType::MI_LOAD_REGISTER_REG;
@@ -736,7 +736,7 @@ HWTEST_F(TheSimplestDeviceQueueFixture, getExecutionModelCleanupSectionSize) {
    EXPECT_EQ(expectedSize, MockDeviceQueueHw<FamilyType>::getExecutionModelCleanupSectionSize());
 }

-HWTEST_F(TheSimplestDeviceQueueFixture, getProfilingEndCmdsSize) {
+HWCMDTEST_F(IGFX_GEN8_CORE, TheSimplestDeviceQueueFixture, getProfilingEndCmdsSize) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    using MI_STORE_REGISTER_MEM = typename FamilyType::MI_STORE_REGISTER_MEM;
    using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
--- a/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp
+++ b/unit_tests/execution_model/enqueue_execution_model_kernel_tests.cpp
@@ -44,7 +44,7 @@ static const char *KernelNames[] = {"kernel_reflection", "simple_block_kernel"};

 typedef ExecutionModelKernelTest ParentKernelEnqueueTest;

-HWTEST_P(ParentKernelEnqueueTest, givenParentKernelWhenEnqueuedThenDeviceQueueDSHHasCorrectlyFilledInterfaceDesriptorTables) {
+HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenParentKernelWhenEnqueuedThenDeviceQueueDSHHasCorrectlyFilledInterfaceDesriptorTables) {
    using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;

    if (std::string(pPlatform->getDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {
@@ -330,7 +330,7 @@ HWTEST_P(ParentKernelEnqueueTest, givenParentKernelWhenEnqueuedThenReflectionSur
    }
 }

-HWTEST_P(ParentKernelEnqueueTest, givenBlockedQueueWhenParentKernelIsEnqueuedThenDeviceQueueIsNotReset) {
+HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenBlockedQueueWhenParentKernelIsEnqueuedThenDeviceQueueIsNotReset) {
    if (std::string(pPlatform->getDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {

        const size_t globalOffsets[3] = {0, 0, 0};
@@ -354,7 +354,7 @@ HWTEST_P(ParentKernelEnqueueTest, givenBlockedQueueWhenParentKernelIsEnqueuedThe
    }
 }

-HWTEST_P(ParentKernelEnqueueTest, givenNonBlockedQueueWhenParentKernelIsEnqueuedThenDeviceQueueDSHAddressIsProgrammedInStateBaseAddressAndDSHIsMadeResident) {
+HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenNonBlockedQueueWhenParentKernelIsEnqueuedThenDeviceQueueDSHAddressIsProgrammedInStateBaseAddressAndDSHIsMadeResident) {
    typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;

    if (std::string(pPlatform->getDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {
@@ -531,7 +531,7 @@ HWTEST_F(ParentKernelEnqueueFixture, ParentKernelEnqueuedToNonBlockedQueueFlushe
    }
 }

-HWTEST_F(ParentKernelEnqueueFixture, ParentKernelEnqueuedWithSchedulerReturnInstanceRunsSimulation) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelEnqueueFixture, ParentKernelEnqueuedWithSchedulerReturnInstanceRunsSimulation) {

    if (pDevice->getSupportedClVersion() >= 20) {

--- a/unit_tests/execution_model/parent_kernel_dispatch_tests.cpp
+++ b/unit_tests/execution_model/parent_kernel_dispatch_tests.cpp
@@ -291,7 +291,7 @@ HWTEST_F(MockParentKernelDispatch, GivenBlockedQueueWhenParentKernelIsDispatched
    }
 }

-HWTEST_F(MockParentKernelDispatch, GivenParentKernelWhenDispatchedThenMediaInterfaceDescriptorLoadIsCorrectlyProgrammed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, MockParentKernelDispatch, GivenParentKernelWhenDispatchedThenMediaInterfaceDescriptorLoadIsCorrectlyProgrammed) {
    typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;

--- a/unit_tests/execution_model/scheduler_dispatch_tests.cpp
+++ b/unit_tests/execution_model/scheduler_dispatch_tests.cpp
@@ -47,7 +47,7 @@ class ExecutionModelSchedulerFixture : public ExecutionModelSchedulerTest,
    }
 };

-HWTEST_F(ExecutionModelSchedulerFixture, dispatchScheduler) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ExecutionModelSchedulerFixture, dispatchScheduler) {
    using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
@@ -172,7 +172,7 @@ HWTEST_F(ExecutionModelSchedulerFixture, dispatchScheduler) {
    }
 }

-HWTEST_F(ExecutionModelSchedulerFixture, dispatchSchedulerDoesNotUseStandardCmdQIOH) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ExecutionModelSchedulerFixture, dispatchSchedulerDoesNotUseStandardCmdQIOH) {
    using INTERFACE_DESCRIPTOR_DATA = typename FamilyType::INTERFACE_DESCRIPTOR_DATA;
    using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;
    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
@@ -204,7 +204,7 @@ HWTEST_F(ExecutionModelSchedulerFixture, dispatchSchedulerDoesNotUseStandardCmdQ
    }
 }

-HWTEST_F(ParentKernelCommandQueueFixture, dispatchSchedulerWithEarlyReturnSetToFirstInstanceDoesNotPutBBStartCmd) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, dispatchSchedulerWithEarlyReturnSetToFirstInstanceDoesNotPutBBStartCmd) {

    if (device->getSupportedClVersion() >= 20) {

--- a/unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp
+++ b/unit_tests/execution_model/submit_blocked_parent_kernel_tests.cpp
@@ -320,7 +320,7 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenParentKernelWhenCommandIsSubmitte
    }
 }

-HWTEST_F(ParentKernelCommandQueueFixture, givenUsedCommandQueueHeapshenParentKernelIsSubmittedThenQueueHeapsAreNotUsed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenUsedCommandQueueHeapshenParentKernelIsSubmittedThenQueueHeapsAreNotUsed) {
    if (device->getSupportedClVersion() >= 20) {
        cl_queue_properties properties[3] = {0};
        MockParentKernel *parentKernel = MockParentKernel::create(*device);
@@ -376,7 +376,7 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenUsedCommandQueueHeapshenParentKer
    }
 }

-HWTEST_F(ParentKernelCommandQueueFixture, givenNotUsedSSHWhenParentKernelIsSubmittedThenExistingSSHIsUsed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenNotUsedSSHWhenParentKernelIsSubmittedThenExistingSSHIsUsed) {
    if (device->getSupportedClVersion() >= 20) {
        cl_queue_properties properties[3] = {0};
        MockParentKernel *parentKernel = MockParentKernel::create(*device);
@@ -425,7 +425,7 @@ HWTEST_F(ParentKernelCommandQueueFixture, givenNotUsedSSHWhenParentKernelIsSubmi
    }
 }

-HWTEST_F(ParentKernelCommandQueueFixture, givenBlockedCommandQueueWhenDispatchWalkerIsCalledThenHeapsHaveProperSizes) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenBlockedCommandQueueWhenDispatchWalkerIsCalledThenHeapsHaveProperSizes) {
    if (device->getSupportedClVersion() >= 20) {
        cl_queue_properties properties[3] = {0};
        std::unique_ptr<MockParentKernel> parentKernel(MockParentKernel::create(*device));
--- a/unit_tests/gen_common/test.h
+++ b/unit_tests/gen_common/test.h
@@ -31,13 +31,17 @@ extern GFXCORE_FAMILY renderCoreFamily;

 #ifdef TESTS_GEN8
 #define BDW_TYPED_TEST_BODY testBodyHw<typename OCLRT::GfxFamilyMapper<IGFX_GEN8_CORE>::GfxFamily>();
+#define BDW_TYPED_CMDTEST_BODY runCmdTestHwIfSupported<typename OCLRT::GfxFamilyMapper<IGFX_GEN8_CORE>::GfxFamily>();
 #else
 #define BDW_TYPED_TEST_BODY
+#define BDW_TYPED_CMDTEST_BODY
 #endif
 #ifdef TESTS_GEN9
 #define SKL_TYPED_TEST_BODY testBodyHw<typename OCLRT::GfxFamilyMapper<IGFX_GEN9_CORE>::GfxFamily>();
+#define SKL_TYPED_CMDTEST_BODY runCmdTestHwIfSupported<typename OCLRT::GfxFamilyMapper<IGFX_GEN9_CORE>::GfxFamily>();
 #else
 #define SKL_TYPED_TEST_BODY
+#define SKL_TYPED_CMDTEST_BODY
 #endif

 // Macros to provide template based testing.
@@ -86,6 +90,62 @@ extern GFXCORE_FAMILY renderCoreFamily;
    HWTEST_TEST_(test_fixture, test_name, test_fixture, \
                 ::testing::internal::GetTypeId<test_fixture>())

+// Macros to provide template based testing.
+// Test can use FamilyType in the test -- equivalent to SKLFamily
+#define HWCMDTEST_TEST_(cmdset_gen_base, test_case_name, test_name, parent_class, parent_id)              \
+    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {                       \
+                                                                                                          \
+      public:                                                                                             \
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)                                                 \
+        () {}                                                                                             \
+                                                                                                          \
+      private:                                                                                            \
+        template <typename FamilyType>                                                                    \
+        void testBodyHw();                                                                                \
+                                                                                                          \
+        template <typename FamilyType, bool ShouldBeTested = FamilyType::supportsCmdSet(cmdset_gen_base)> \
+        auto runCmdTestHwIfSupported() -> typename std::enable_if<ShouldBeTested>::type {                 \
+            testBodyHw<FamilyType>();                                                                     \
+        }                                                                                                 \
+                                                                                                          \
+        template <typename FamilyType, bool ShouldBeTested = FamilyType::supportsCmdSet(cmdset_gen_base)> \
+        auto runCmdTestHwIfSupported() -> typename std::enable_if<false == ShouldBeTested>::type {        \
+            /* do nothing */                                                                              \
+        }                                                                                                 \
+                                                                                                          \
+        void TestBody() override {                                                                        \
+            switch (::renderCoreFamily) {                                                                 \
+            case IGFX_GEN8_CORE:                                                                          \
+                BDW_TYPED_CMDTEST_BODY                                                                    \
+                break;                                                                                    \
+            case IGFX_GEN9_CORE:                                                                          \
+                SKL_TYPED_CMDTEST_BODY                                                                    \
+                break;                                                                                    \
+            default:                                                                                      \
+                ASSERT_TRUE((false && "Unknown hardware family"));                                        \
+                break;                                                                                    \
+            }                                                                                             \
+        }                                                                                                 \
+        static ::testing::TestInfo *const test_info_ GTEST_ATTRIBUTE_UNUSED_;                             \
+        GTEST_DISALLOW_COPY_AND_ASSIGN_(                                                                  \
+            GTEST_TEST_CLASS_NAME_(test_case_name, test_name));                                           \
+    };                                                                                                    \
+                                                                                                          \
+    ::testing::TestInfo *const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::test_info_ =            \
+        ::testing::internal::MakeAndRegisterTestInfo(                                                     \
+            #test_case_name, #test_name, NULL, NULL,                                                      \
+            (parent_id),                                                                                  \
+            parent_class::SetUpTestCase,                                                                  \
+            parent_class::TearDownTestCase,                                                               \
+            new ::testing::internal::TestFactoryImpl<                                                     \
+                GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);                                      \
+    template <typename FamilyType>                                                                        \
+    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::testBodyHw()
+
+#define HWCMDTEST_F(cmdset_gen_base, test_fixture, test_name)               \
+    HWCMDTEST_TEST_(cmdset_gen_base, test_fixture, test_name, test_fixture, \
+                    ::testing::internal::GetTypeId<test_fixture>())
+
 #define FAMILYTEST_TEST_(test_case_name, test_name, parent_class, parent_id, match_core, match_product) \
    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {                     \
      public:                                                                                           \
@@ -164,6 +224,60 @@ extern GFXCORE_FAMILY renderCoreFamily;
        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry();                                             \
    template <typename FamilyType>                                                                                      \
    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::testBodyHw()
+
+#define HWCMDTEST_P(cmdset_gen_base, test_case_name, test_name)                                                         \
+    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public test_case_name {                                   \
+      public:                                                                                                           \
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)                                                               \
+        () {}                                                                                                           \
+        template <typename FamilyType>                                                                                  \
+        void testBodyHw();                                                                                              \
+                                                                                                                        \
+        template <typename FamilyType, bool ShouldBeTested = FamilyType::supportsCmdSet(cmdset_gen_base)>               \
+        auto runCmdTestHwIfSupported() -> typename std::enable_if<ShouldBeTested>::type {                               \
+            testBodyHw<FamilyType>();                                                                                   \
+        }                                                                                                               \
+                                                                                                                        \
+        template <typename FamilyType, bool ShouldBeTested = FamilyType::supportsCmdSet(cmdset_gen_base)>               \
+        auto runCmdTestHwIfSupported() -> typename std::enable_if<false == ShouldBeTested>::type {                      \
+            /* do nothing */                                                                                            \
+        }                                                                                                               \
+                                                                                                                        \
+        virtual void TestBody() {                                                                                       \
+            switch (::renderCoreFamily) {                                                                               \
+            case IGFX_GEN8_CORE:                                                                                        \
+                BDW_TYPED_CMDTEST_BODY                                                                                  \
+                break;                                                                                                  \
+            case IGFX_GEN9_CORE:                                                                                        \
+                SKL_TYPED_CMDTEST_BODY                                                                                  \
+                break;                                                                                                  \
+            default:                                                                                                    \
+                ASSERT_TRUE((false && "Unknown hardware family"));                                                      \
+                break;                                                                                                  \
+            }                                                                                                           \
+        }                                                                                                               \
+                                                                                                                        \
+      private:                                                                                                          \
+        static int AddToRegistry() {                                                                                    \
+            ::testing::UnitTest::GetInstance()->parameterized_test_registry().GetTestCasePatternHolder<test_case_name>( \
+                                                                                 #test_case_name, __FILE__, __LINE__)   \
+                ->AddTestPattern(                                                                                       \
+                    #test_case_name,                                                                                    \
+                    #test_name,                                                                                         \
+                    new ::testing::internal::TestMetaFactory<                                                           \
+                        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>());                                          \
+            return 0;                                                                                                   \
+        }                                                                                                               \
+        static int gtest_registering_dummy_;                                                                            \
+        GTEST_DISALLOW_COPY_AND_ASSIGN_(                                                                                \
+            GTEST_TEST_CLASS_NAME_(test_case_name, test_name));                                                         \
+    };                                                                                                                  \
+    int GTEST_TEST_CLASS_NAME_(test_case_name,                                                                          \
+                               test_name)::gtest_registering_dummy_ =                                                   \
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry();                                             \
+    template <typename FamilyType>                                                                                      \
+    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::testBodyHw()
+
 #ifdef TESTS_GEN8
 #define GEN8TEST_F(test_fixture, test_name)                          \
    FAMILYTEST_TEST_(test_fixture, test_name, test_fixture,          \
--- a/unit_tests/helpers/kernel_commands_tests.cpp
+++ b/unit_tests/helpers/kernel_commands_tests.cpp
@@ -109,7 +109,7 @@ HWTEST_F(KernelCommandsTest, programInterfaceDescriptorDataResourceUsage) {
    EXPECT_EQ(sizeof(INTERFACE_DESCRIPTOR_DATA), usedIndirectHeapAfter - usedIndirectHeapBefore);
 }

-HWTEST_F(KernelCommandsTest, programMediaInterfaceDescriptorLoadResourceUsage) {
+HWCMDTEST_F(IGFX_GEN8_CORE, KernelCommandsTest, programMediaInterfaceDescriptorLoadResourceUsage) {
    CommandQueueHw<FamilyType> cmdQ(nullptr, pDevice, 0);

    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
@@ -127,7 +127,7 @@ HWTEST_F(KernelCommandsTest, programMediaInterfaceDescriptorLoadResourceUsage) {
    EXPECT_EQ(sizeof(MEDIA_INTERFACE_DESCRIPTOR_LOAD) + sizeof(MEDIA_STATE_FLUSH), usedAfter - usedBefore);
 }

-HWTEST_F(KernelCommandsTest, programMediaStateFlushResourceUsage) {
+HWCMDTEST_F(IGFX_GEN8_CORE, KernelCommandsTest, programMediaStateFlushResourceUsage) {
    CommandQueueHw<FamilyType> cmdQ(nullptr, pDevice, 0);

    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
--- a/unit_tests/kernel/clone_kernel_tests.cpp
+++ b/unit_tests/kernel/clone_kernel_tests.cpp
@@ -395,7 +395,7 @@ TEST_F(CloneKernelTest, cloneKernelWithArgSampler) {
    EXPECT_EQ(GetNormCoordsEnum(sampler->normalizedCoordinates), *pNormalizedCoords);
 }

-HWTEST_F(CloneKernelTest, cloneKernelWithArgDeviceQueue) {
+HWCMDTEST_F(IGFX_GEN8_CORE, CloneKernelTest, cloneKernelWithArgDeviceQueue) {
    cl_queue_properties queueProps[5] = {
        CL_QUEUE_PROPERTIES,
        CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE,
--- a/unit_tests/kernel/kernel_slm_tests.cpp
+++ b/unit_tests/kernel/kernel_slm_tests.cpp
@@ -81,7 +81,7 @@ struct KernelSLMAndBarrierTest : public DeviceFixture,

 static uint32_t slmSizeInKb[] = {1, 4, 8, 16, 32, 64};

-HWTEST_P(KernelSLMAndBarrierTest, test_SLMProgramming) {
+HWCMDTEST_P(IGFX_GEN8_CORE, KernelSLMAndBarrierTest, test_SLMProgramming) {
    ASSERT_NE(nullptr, pDevice);
    CommandQueueHw<FamilyType> cmdQ(nullptr, pDevice, 0);
    typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
--- a/unit_tests/mt_tests/device_queue/device_queue_mt_tests.cpp
+++ b/unit_tests/mt_tests/device_queue/device_queue_mt_tests.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -29,7 +29,7 @@ using namespace OCLRT;

 typedef ::testing::Test DeviceQueueHwMtTest;

-HWTEST_F(DeviceQueueHwMtTest, givenTakenIgilCriticalSectionWhenSecondThreadIsWaitingThenDontHang) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DeviceQueueHwMtTest, givenTakenIgilCriticalSectionWhenSecondThreadIsWaitingThenDontHang) {
    auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(nullptr));
    auto context = std::unique_ptr<MockContext>(new MockContext());

--- a/unit_tests/os_interface/linux/drm_command_stream_tests.cpp
+++ b/unit_tests/os_interface/linux/drm_command_stream_tests.cpp
@@ -529,7 +529,7 @@ struct DrmCsrVfeTests : ::testing::Test {
    CommandStreamReceiver *oldCsr = nullptr;
 };

-HWTEST_F(DrmCsrVfeTests, givenNonDirtyVfeForDefaultContextWhenLowPriorityIsFlushedThenReprogram) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DrmCsrVfeTests, givenNonDirtyVfeForDefaultContextWhenLowPriorityIsFlushedThenReprogram) {
    std::unique_ptr<MockDevice> device(DeviceHelper<>::create(nullptr));
    auto mockCsr = new MyCsr<FamilyType>;

@@ -557,7 +557,7 @@ HWTEST_F(DrmCsrVfeTests, givenNonDirtyVfeForDefaultContextWhenLowPriorityIsFlush
    mockCsr->getMemoryManager()->freeGraphicsMemory(graphicAlloc);
 }

-HWTEST_F(DrmCsrVfeTests, givenNonDirtyVfeForLowPriorityContextWhenDefaultPriorityIsFlushedThenReprogram) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DrmCsrVfeTests, givenNonDirtyVfeForLowPriorityContextWhenDefaultPriorityIsFlushedThenReprogram) {
    std::unique_ptr<MockDevice> device(DeviceHelper<>::create(nullptr));
    auto mockCsr = new MyCsr<FamilyType>;

@@ -585,7 +585,7 @@ HWTEST_F(DrmCsrVfeTests, givenNonDirtyVfeForLowPriorityContextWhenDefaultPriorit
    mockCsr->getMemoryManager()->freeGraphicsMemory(graphicAlloc);
 }

-HWTEST_F(DrmCsrVfeTests, givenNonDirtyVfeForLowPriorityContextWhenLowPriorityIsFlushedThenDontReprogram) {
+HWCMDTEST_F(IGFX_GEN8_CORE, DrmCsrVfeTests, givenNonDirtyVfeForLowPriorityContextWhenLowPriorityIsFlushedThenDontReprogram) {
    std::unique_ptr<MockDevice> device(DeviceHelper<>::create(nullptr));
    auto mockCsr = new MyCsr<FamilyType>;

--- a/unit_tests/profiling/profiling_tests.cpp
+++ b/unit_tests/profiling/profiling_tests.cpp
@@ -86,7 +86,7 @@ struct ProfilingTests : public CommandEnqueueFixture,
    uint32_t crossThreadData[32];
 };

-HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -104,7 +104,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithKernelW
    EXPECT_GE(commandStreamTask.getAvailableSpace(), requiredSize);
 }

-HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithNoKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithNoKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -122,7 +122,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithNoKerne
    EXPECT_GE(commandStreamMarker.getAvailableSpace(), requiredSize);
 }

-HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithTwoKernelsInMdiWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithTwoKernelsInMdiWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -145,7 +145,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfilingAndForWorkloadWithTwoKern
 #   Two additional PIPE_CONTROLs are expected before first MI_STORE_REGISTER_MEM (which is before GPGPU_WALKER)
 #   and after second MI_STORE_REGISTER_MEM (which is after GPGPU_WALKER).
 */
-HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfolingWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueWithProfolingWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

@@ -199,7 +199,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueWithProfolingWHENWalkerIsDispatchedTHE
 #   One additional MI_STORE_REGISTER_MEM is expected before and after GPGPU_WALKER.
 */

-HWTEST_F(ProfilingTests, GIVENCommandQueueWithProflingWHENWalkerIsDispatchedTHENMiStoreRegisterMemIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueWithProflingWHENWalkerIsDispatchedTHENMiStoreRegisterMemIsPresentInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

@@ -253,7 +253,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueWithProflingWHENWalkerIsDispatchedTHEN
 #   and after second MI_STORE_REGISTER_MEM (which is after GPGPU_WALKER).
 #   If queue is blocked commands should be added to event
 */
-HWTEST_F(ProfilingTests, GIVENCommandQueueBlockedWithProfilingWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueBlockedWithProfilingWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

@@ -309,7 +309,7 @@ HWTEST_F(ProfilingTests, GIVENCommandQueueBlockedWithProfilingWHENWalkerIsDispat
 #   If queue is blocked commands should be added to event
 */

-HWTEST_F(ProfilingTests, GIVENCommandQueueBlockedWithProfilingWHENWalkerIsDispatchedTHENMiStoreRegisterMemIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingTests, GIVENCommandQueueBlockedWithProfilingWHENWalkerIsDispatchedTHENMiStoreRegisterMemIsPresentInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;

@@ -475,7 +475,7 @@ struct ProfilingWithPerfCountersTests : public ProfilingTests,
        PerformanceCountersFixture::TearDown();
    }
 };
-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -505,7 +505,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
    EXPECT_TRUE(retVal);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithNoKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCounterAndForWorkloadWithNoKernelWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -527,7 +527,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
    pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersAndForWorkloadWithTwoKernelsInMdiWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersAndForWorkloadWithTwoKernelsInMdiWHENGetCSFromCmdQueueTHENEnoughSpaceInCS) {
    typedef typename FamilyType::MI_STORE_REGISTER_MEM MI_STORE_REGISTER_MEM;
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
@@ -556,7 +556,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
    pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
@@ -619,7 +619,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
    pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersNoUserRegistersWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersNoUserRegistersWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
@@ -682,7 +682,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCount
    pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueBlockedWithProflingPerfCounterWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueBlockedWithProflingPerfCounterWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;
@@ -745,7 +745,7 @@ HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueBlockedWithProflingPer
    pCmdQ->setPerfCountersEnabled(false, UINT32_MAX);
 }

-HWTEST_F(ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersNoEventWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsNotPresentInCS) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GIVENCommandQueueWithProfilingPerfCountersNoEventWHENWalkerIsDispatchedTHENPipeControlWithTimeStampIsNotPresentInCS) {
    typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL;
    typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
    typedef typename FamilyType::MI_REPORT_PERF_COUNT MI_REPORT_PERF_COUNT;