Move aub unit tests to shared directory

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>

shared/test/unit_test/aub/CMakeLists.txt

@@ -0,0 +1,20 @@
+#
+# Copyright (C) 2018-2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(NEO_SHARED_aub_helper_tests
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/aub_helper_tests.cpp
+)
+
+if(NOT DEFINED AUB_STREAM_PROJECT_NAME)
+  list(APPEND NEO_SHARED_aub_helper_tests
+       ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_stubs_tests.cpp
+  )
+endif()
+
+target_sources(${TARGET_NAME} PRIVATE ${NEO_SHARED_aub_helper_tests})
+add_subdirectories()

shared/test/unit_test/aub/aub_center_tests.cpp

@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2018-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/gmm_helper/gmm_helper.h"
+#include "shared/source/helpers/basic_math.h"
+#include "shared/source/helpers/hw_helper.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/source/os_interface/hw_info_config.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/helpers/hw_helper_tests.h"
+#include "shared/test/common/mocks/mock_aub_center.h"
+#include "shared/test/common/mocks/mock_aub_manager.h"
+
+#include "gtest/gtest.h"
+#include "third_party/aub_stream/headers/aubstream.h"
+
+using namespace NEO;
+
+struct AubCenterTests : public ::testing::Test {
+    DebugManagerStateRestore restorer;
+    GmmHelper gmmHelper{nullptr, defaultHwInfo.get()};
+};
+
+TEST_F(AubCenterTests, GivenUseAubStreamDebugVariableNotSetWhenAubCenterIsCreatedThenAubCenterDoesNotCreateAubManager) {
+    DebugManager.flags.UseAubStream.set(false);
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+    EXPECT_EQ(nullptr, aubCenter.aubManager.get());
+}
+
+TEST_F(AubCenterTests, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenCreateAubManagerWithCorrectParameters) {
+    DebugManager.flags.UseAubStream.set(false);
+
+    MockAubManager *mockAubManager = new MockAubManager(defaultHwInfo->platform.eProductFamily, 4, 8 * MB, defaultHwInfo->platform.usRevId, true, aub_stream::mode::aubFile, defaultHwInfo->capabilityTable.gpuAddressSpace);
+    MockAubCenter mockAubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+    mockAubCenter.aubManager = std::unique_ptr<MockAubManager>(mockAubManager);
+
+    EXPECT_EQ(defaultHwInfo->platform.eProductFamily, mockAubManager->mockAubManagerParams.productFamily);
+    EXPECT_EQ(4, mockAubManager->mockAubManagerParams.devicesCount);
+    EXPECT_EQ(8 * MB, mockAubManager->mockAubManagerParams.memoryBankSize);
+    EXPECT_EQ(defaultHwInfo->platform.usRevId, mockAubManager->mockAubManagerParams.stepping);
+    EXPECT_EQ(true, mockAubManager->mockAubManagerParams.localMemorySupported);
+    EXPECT_EQ(aub_stream::mode::aubFile, mockAubManager->mockAubManagerParams.streamMode);
+    EXPECT_EQ(defaultHwInfo->capabilityTable.gpuAddressSpace, mockAubManager->mockAubManagerParams.gpuAddressSpace);
+}
+
+TEST_F(AubCenterTests, GivenDefaultSetCommandStreamReceiverFlagAndAubFileNameWhenGettingAubStreamModeThenModeAubFileIsReturned) {
+    DebugManager.flags.UseAubStream.set(true);
+
+    std::string aubFile("test.aub");
+    auto mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_AUB);
+
+    EXPECT_EQ(aub_stream::mode::aubFile, mode);
+}
+
+TEST_F(AubCenterTests, GivenCsrHwAndEmptyAubFileNameWhenGettingAubStreamModeThenModeAubFileIsReturned) {
+    DebugManager.flags.UseAubStream.set(true);
+
+    std::string aubFile("");
+    auto mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_HW);
+
+    EXPECT_EQ(aub_stream::mode::aubFile, mode);
+}
+
+TEST_F(AubCenterTests, GivenCsrHwAndNotEmptyAubFileNameWhenGettingAubStreamModeThenModeAubFileIsReturned) {
+    DebugManager.flags.UseAubStream.set(true);
+
+    std::string aubFile("test.aub");
+    auto mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_HW);
+
+    EXPECT_EQ(aub_stream::mode::aubFile, mode);
+}
+
+TEST_F(AubCenterTests, WhenAubManagerIsCreatedThenCorrectSteppingIsSet) {
+    struct {
+        __REVID stepping;
+        uint32_t expectedAubStreamStepping;
+    } steppingPairsToTest[] = {
+        {REVISION_A0, AubMemDump::SteppingValues::A},
+        {REVISION_A1, AubMemDump::SteppingValues::A},
+        {REVISION_A3, AubMemDump::SteppingValues::A},
+        {REVISION_B, AubMemDump::SteppingValues::B},
+        {REVISION_C, AubMemDump::SteppingValues::C},
+        {REVISION_D, AubMemDump::SteppingValues::D},
+        {REVISION_K, AubMemDump::SteppingValues::K}};
+
+    DebugManager.flags.UseAubStream.set(true);
+
+    auto hwInfo = *defaultHwInfo;
+    const auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
+    for (auto steppingPair : steppingPairsToTest) {
+        auto hwRevId = hwInfoConfig.getHwRevIdFromStepping(steppingPair.stepping, hwInfo);
+        if (hwRevId == CommonConstants::invalidStepping) {
+            continue;
+        }
+
+        hwInfo.platform.usRevId = hwRevId;
+        MockAubCenter aubCenter(&hwInfo, gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+        EXPECT_EQ(steppingPair.expectedAubStreamStepping, aubCenter.stepping);
+    }
+}
+
+TEST_F(AubCenterTests, GivenCsrTypeWhenGettingAubStreamModeThenCorrectModeIsReturned) {
+    DebugManager.flags.UseAubStream.set(true);
+
+    std::string aubFile("test.aub");
+
+    auto mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_AUB);
+    EXPECT_EQ(aub_stream::mode::aubFile, mode);
+
+    mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_TBX);
+    EXPECT_EQ(aub_stream::mode::tbx, mode);
+
+    mode = AubCenter::getAubStreamMode(aubFile, CommandStreamReceiverType::CSR_TBX_WITH_AUB);
+    EXPECT_EQ(aub_stream::mode::aubFileAndTbx, mode);
+}
+
+TEST_F(AubCenterTests, GivenSetCommandStreamReceiverFlagEqualDefaultHwWhenAubManagerIsCreatedThenCsrTypeDefinesAubStreamMode) {
+    DebugManager.flags.UseAubStream.set(true);
+    DebugManager.flags.SetCommandStreamReceiver.set(-1);
+
+    std::vector<CommandStreamReceiverType> aubTypes = {CommandStreamReceiverType::CSR_HW,
+                                                       CommandStreamReceiverType::CSR_HW_WITH_AUB,
+                                                       CommandStreamReceiverType::CSR_AUB};
+
+    for (auto type : aubTypes) {
+        MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, true, "test", type);
+        EXPECT_EQ(aub_stream::mode::aubFile, aubCenter.aubStreamMode);
+    }
+
+    MockAubCenter aubCenter2(defaultHwInfo.get(), gmmHelper, true, "", CommandStreamReceiverType::CSR_TBX);
+    EXPECT_EQ(aub_stream::mode::tbx, aubCenter2.aubStreamMode);
+
+    MockAubCenter aubCenter3(defaultHwInfo.get(), gmmHelper, true, "", CommandStreamReceiverType::CSR_TBX_WITH_AUB);
+    EXPECT_EQ(aub_stream::mode::aubFileAndTbx, aubCenter3.aubStreamMode);
+}
+
+TEST_F(AubCenterTests, GivenSetCommandStreamReceiverFlagSetWhenAubManagerIsCreatedThenDebugFlagDefinesAubStreamMode) {
+    DebugManager.flags.UseAubStream.set(true);
+
+    DebugManager.flags.SetCommandStreamReceiver.set(CommandStreamReceiverType::CSR_TBX);
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, true, "", CommandStreamReceiverType::CSR_AUB);
+    EXPECT_EQ(aub_stream::mode::tbx, aubCenter.aubStreamMode);
+
+    DebugManager.flags.SetCommandStreamReceiver.set(CommandStreamReceiverType::CSR_TBX_WITH_AUB);
+
+    MockAubCenter aubCenter2(defaultHwInfo.get(), gmmHelper, true, "", CommandStreamReceiverType::CSR_AUB);
+    EXPECT_EQ(aub_stream::mode::aubFileAndTbx, aubCenter2.aubStreamMode);
+}
+
+TEST_F(AubCenterTests, GivenAubCenterInSubCaptureModeWhenItIsCreatedWithoutDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDefaults) {
+    DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast<int32_t>(AubSubCaptureManager::SubCaptureMode::Filter));
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+    auto subCaptureCommon = aubCenter.getSubCaptureCommon();
+    EXPECT_NE(nullptr, subCaptureCommon);
+
+    EXPECT_EQ(0u, subCaptureCommon->subCaptureFilter.dumpKernelStartIdx);
+    EXPECT_EQ(static_cast<uint32_t>(-1), subCaptureCommon->subCaptureFilter.dumpKernelEndIdx);
+    EXPECT_STREQ("", subCaptureCommon->subCaptureFilter.dumpKernelName.c_str());
+}
+
+TEST_F(AubCenterTests, GivenAubCenterInSubCaptureModeWhenItIsCreatedWithDebugFilterSettingsThenItInitializesSubCaptureFiltersWithDebugFilterSettings) {
+    DebugManager.flags.AUBDumpSubCaptureMode.set(static_cast<int32_t>(AubSubCaptureManager::SubCaptureMode::Filter));
+    DebugManager.flags.AUBDumpFilterKernelStartIdx.set(10);
+    DebugManager.flags.AUBDumpFilterKernelEndIdx.set(100);
+    DebugManager.flags.AUBDumpFilterKernelName.set("kernel_name");
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+    auto subCaptureCommon = aubCenter.getSubCaptureCommon();
+    EXPECT_NE(nullptr, subCaptureCommon);
+
+    EXPECT_EQ(static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelStartIdx.get()), subCaptureCommon->subCaptureFilter.dumpKernelStartIdx);
+    EXPECT_EQ(static_cast<uint32_t>(DebugManager.flags.AUBDumpFilterKernelEndIdx.get()), subCaptureCommon->subCaptureFilter.dumpKernelEndIdx);
+    EXPECT_STREQ(DebugManager.flags.AUBDumpFilterKernelName.get().c_str(), subCaptureCommon->subCaptureFilter.dumpKernelName.c_str());
+}

shared/test/unit_test/aub/aub_center_using_aubstream_stubs_tests.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2018-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/gmm_helper/gmm_helper.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/source/helpers/options.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_aub_center.h"
+
+#include "gtest/gtest.h"
+#include "third_party/aub_stream/headers/aubstream.h"
+
+using namespace NEO;
+
+namespace aub_stream_stubs {
+extern uint16_t tbxServerPort;
+extern std::string tbxServerIp;
+extern bool tbxFrontdoorMode;
+} // namespace aub_stream_stubs
+
+TEST(AubCenter, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenAubManagerIsNotCreated) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "test", CommandStreamReceiverType::CSR_AUB);
+
+    EXPECT_EQ(nullptr, aubCenter.aubManager.get());
+}
+
+TEST(AubCenter, GivenUseAubStreamAndTbxServerIpDebugVariableSetWhenAubCenterIsCreatedThenServerIpIsModified) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+    DebugManager.flags.TbxServer.set("10.10.10.10");
+    VariableBackup<std::string> backup(&aub_stream_stubs::tbxServerIp);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_TBX);
+
+    EXPECT_STREQ("10.10.10.10", aub_stream_stubs::tbxServerIp.c_str());
+}
+
+TEST(AubCenter, GivenUseAubStreamAndTbxServerPortDebugVariableSetWhenAubCenterIsCreatedThenServerIpIsModified) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+    DebugManager.flags.TbxPort.set(1234);
+
+    VariableBackup<uint16_t> backup(&aub_stream_stubs::tbxServerPort);
+
+    uint16_t port = 1234u;
+    EXPECT_NE(port, aub_stream_stubs::tbxServerPort);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_TBX);
+    EXPECT_EQ(port, aub_stream_stubs::tbxServerPort);
+}
+
+TEST(AubCenter, GivenUseAubStreamAndTbxFrontdoorModeDebugVariableSetWhenAubCenterIsCreatedThenFrontdoorModeIsModified) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+    DebugManager.flags.TbxFrontdoorMode.set(true);
+
+    VariableBackup<bool> backup(&aub_stream_stubs::tbxFrontdoorMode);
+
+    EXPECT_FALSE(aub_stream_stubs::tbxFrontdoorMode);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_TBX);
+    EXPECT_TRUE(aub_stream_stubs::tbxFrontdoorMode);
+}

shared/test/unit_test/aub/aub_helper_tests.cpp

@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2018-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/aub/aub_helper.h"
+#include "shared/source/aub_mem_dump/aub_mem_dump.h"
+#include "shared/source/aub_mem_dump/page_table_entry_bits.h"
+#include "shared/source/command_stream/aub_command_stream_receiver_hw.h"
+#include "shared/source/helpers/basic_math.h"
+#include "shared/source/helpers/hw_helper.h"
+#include "shared/source/tbx/tbx_proto.h"
+#include "shared/test/common/fixtures/device_fixture.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/mocks/mock_lrca_helper.h"
+#include "shared/test/common/test_macros/test.h"
+
+using namespace NEO;
+
+TEST(AubHelper, GivenZeroPdEntryBitsWhenGetMemTraceIsCalledThenTraceNonLocalIsReturned) {
+    int hint = AubHelper::getMemTrace(0u);
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceNonlocal, hint);
+}
+
+TEST(AubHelper, WhenGetPtEntryBitsIsCalledThenEntryBitsAreNotMasked) {
+    uint64_t entryBits = BIT(PageTableEntry::presentBit) |
+                         BIT(PageTableEntry::writableBit) |
+                         BIT(PageTableEntry::userSupervisorBit);
+    uint64_t maskedEntryBits = AubHelper::getPTEntryBits(entryBits);
+    EXPECT_EQ(entryBits, maskedEntryBits);
+}
+
+TEST(AubHelper, GivenMultipleSubDevicesWhenGettingDeviceCountThenCorrectValueIsReturned) {
+    DebugManagerStateRestore stateRestore;
+    FeatureTable featureTable = {};
+    WorkaroundTable workaroundTable = {};
+    RuntimeCapabilityTable capTable = {};
+    GT_SYSTEM_INFO sysInfo = {};
+    PLATFORM platform = {};
+    HardwareInfo hwInfo{&platform, &featureTable, &workaroundTable, &sysInfo, capTable};
+    DebugManager.flags.CreateMultipleSubDevices.set(2);
+
+    uint32_t devicesCount = HwHelper::getSubDevicesCount(&hwInfo);
+    EXPECT_EQ(devicesCount, 2u);
+
+    DebugManager.flags.CreateMultipleSubDevices.set(0);
+    devicesCount = HwHelper::getSubDevicesCount(&hwInfo);
+    EXPECT_EQ(devicesCount, 1u);
+}
+
+TEST(AubHelper, WhenGetMemTraceIsCalledWithLocalMemoryPDEntryBitsThenTraceLocalIsReturned) {
+    int hint = AubHelper::getMemTrace(BIT(PageTableEntry::localMemoryBit));
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceLocal, hint);
+}
+
+TEST(AubHelper, WhenMaskPTEntryBitsIsCalledThenLocalMemoryBitIsMasked) {
+    uint64_t entryBits = BIT(PageTableEntry::presentBit) |
+                         BIT(PageTableEntry::writableBit) |
+                         BIT(PageTableEntry::userSupervisorBit) |
+                         BIT(PageTableEntry::localMemoryBit);
+    uint64_t maskedEntryBits = AubHelper::getPTEntryBits(entryBits);
+    EXPECT_EQ(entryBits & ~BIT(PageTableEntry::localMemoryBit), maskedEntryBits);
+}
+
+TEST(AubHelper, WhenGetMemTypeIsCalledWithAGivenAddressSpaceThenCorrectMemTypeIsReturned) {
+    uint32_t addressSpace = AubHelper::getMemType(AubMemDump::AddressSpaceValues::TraceLocal);
+    EXPECT_EQ(mem_types::MEM_TYPE_LOCALMEM, addressSpace);
+
+    addressSpace = AubHelper::getMemType(AubMemDump::AddressSpaceValues::TraceNonlocal);
+    EXPECT_EQ(mem_types::MEM_TYPE_SYSTEM, addressSpace);
+}
+
+TEST(AubHelper, WhenHBMSizePerTileInGigabytesIsSetThenGetMemBankSizeReturnsCorrectValue) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.HBMSizePerTileInGigabytes.set(8);
+
+    HardwareInfo hwInfo = *defaultHwInfo;
+    GT_SYSTEM_INFO &sysInfo = hwInfo.gtSystemInfo;
+
+    sysInfo.MultiTileArchInfo.IsValid = true;
+    sysInfo.MultiTileArchInfo.TileCount = 1;
+    EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+
+    sysInfo.MultiTileArchInfo.TileCount = 2;
+    EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+
+    sysInfo.MultiTileArchInfo.TileCount = 4;
+    EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+}
+
+TEST(AubHelper, WhenHBMSizePerTileInGigabytesIsNotSetThenGetMemBankSizeReturnsCorrectValue) {
+    HardwareInfo hwInfo = *defaultHwInfo;
+    GT_SYSTEM_INFO &sysInfo = hwInfo.gtSystemInfo;
+
+    sysInfo.MultiTileArchInfo.IsValid = true;
+    sysInfo.MultiTileArchInfo.TileCount = 1;
+    EXPECT_EQ(32 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+
+    sysInfo.MultiTileArchInfo.TileCount = 2;
+    EXPECT_EQ(16 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+
+    sysInfo.MultiTileArchInfo.TileCount = 4;
+    EXPECT_EQ(8 * MemoryConstants::gigaByte, AubHelper::getPerTileLocalMemorySize(&hwInfo));
+}
+
+using AubHelperHwTest = Test<DeviceFixture>;
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetDataHintForPml4EntryIsCalledThenTraceNotypeIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int dataHint = aubHelper.getDataHintForPml4Entry();
+    EXPECT_EQ(AubMemDump::DataTypeHintValues::TraceNotype, dataHint);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetDataHintForPdpEntryIsCalledThenTraceNotypeIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int dataHint = aubHelper.getDataHintForPdpEntry();
+    EXPECT_EQ(AubMemDump::DataTypeHintValues::TraceNotype, dataHint);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetDataHintForPdEntryIsCalledThenTraceNotypeIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int dataHint = aubHelper.getDataHintForPdEntry();
+    EXPECT_EQ(AubMemDump::DataTypeHintValues::TraceNotype, dataHint);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetDataHintForPtEntryIsCalledThenTraceNotypeIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int dataHint = aubHelper.getDataHintForPtEntry();
+    EXPECT_EQ(AubMemDump::DataTypeHintValues::TraceNotype, dataHint);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetMemTraceForPml4EntryIsCalledThenTracePml4EntryIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int addressSpace = aubHelper.getMemTraceForPml4Entry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TracePml4Entry, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetMemTraceForPdpEntryIsCalledThenTracePhysicalPdpEntryIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int addressSpace = aubHelper.getMemTraceForPdpEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TracePhysicalPdpEntry, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetMemTraceForPd4EntryIsCalledThenTracePpgttPdEntryIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int addressSpace = aubHelper.getMemTraceForPdEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TracePpgttPdEntry, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenDisabledLocalMemoryWhenGetMemTraceForPtEntryIsCalledThenTracePpgttEntryIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(false);
+    int addressSpace = aubHelper.getMemTraceForPtEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TracePpgttEntry, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPml4EntryIsCalledThenTraceLocalIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(true);
+    int addressSpace = aubHelper.getMemTraceForPml4Entry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceLocal, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPdpEntryIsCalledThenTraceLocalIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(true);
+    int addressSpace = aubHelper.getMemTraceForPdpEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceLocal, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPd4EntryIsCalledThenTraceLocalIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(true);
+    int addressSpace = aubHelper.getMemTraceForPdEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceLocal, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, GivenEnabledLocalMemoryWhenGetMemTraceForPtEntryIsCalledThenTraceLocalIsReturned) {
+    AubHelperHw<FamilyType> aubHelper(true);
+    int addressSpace = aubHelper.getMemTraceForPtEntry();
+    EXPECT_EQ(AubMemDump::AddressSpaceValues::TraceLocal, addressSpace);
+}
+
+HWTEST_F(AubHelperHwTest, givenLrcaHelperWhenContextIsInitializedThenContextFlagsAreSet) {
+    const auto &csTraits = CommandStreamReceiverSimulatedCommonHw<FamilyType>::getCsTraits(aub_stream::ENGINE_RCS);
+    MockLrcaHelper lrcaHelper(csTraits.mmioBase);
+
+    std::unique_ptr<void, std::function<void(void *)>> lrcaBase(alignedMalloc(csTraits.sizeLRCA, csTraits.alignLRCA), alignedFree);
+
+    lrcaHelper.initialize(lrcaBase.get());
+    ASSERT_NE(0u, lrcaHelper.setContextSaveRestoreFlagsCalled);
+}

shared/test/unit_test/xe_hp_core/CMakeLists.txt

@@ -5,9 +5,16 @@
 #
 
 if(TESTS_XE_HP_CORE)
-  target_sources(neo_shared_tests PRIVATE
-                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hp_core_tests.cpp
+  set(NEO_SHARED_tests_xe_hp_core
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hp_core_tests.cpp
   )
+
+  if(DEFINED AUB_STREAM_PROJECT_NAME)
+    list(APPEND NEO_SHARED_tests_xe_hp_core
+         ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_lib_tests_xe_hp_core.cpp
+    )
+  endif()
+  target_sources(${TARGET_NAME} PRIVATE ${NEO_SHARED_tests_xe_hp_core})
   add_subdirectories()
 endif()

shared/test/unit_test/xe_hp_core/aub_center_using_aubstream_lib_tests_xe_hp_core.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/gmm_helper/gmm_helper.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/mocks/mock_aub_center.h"
+#include "shared/test/common/test_macros/test.h"
+using namespace NEO;
+using XeHpCoreAubCenterTests = ::testing::Test;
+
+XE_HP_CORE_TEST_F(XeHpCoreAubCenterTests, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenAubCenterCreatesAubManager) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+
+    EXPECT_NE(nullptr, aubCenter.aubManager.get());
+}

shared/test/unit_test/xe_hpc_core/CMakeLists.txt

@@ -5,11 +5,19 @@
 #
 
 if(TESTS_XE_HPC_CORE)
-  target_sources(neo_shared_tests PRIVATE
-                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_2_tests_xe_hpc_core.cpp
-                 ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpc_core_tests.cpp
-                 ${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_xe_hpc_core_tests.cpp
+  set(NEO_SHARED_tests_xe_hpc_core
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_2_tests_xe_hpc_core.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpc_core_tests.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_xe_hpc_core_tests.cpp
   )
+
+  if(DEFINED AUB_STREAM_PROJECT_NAME)
+    list(APPEND NEO_SHARED_tests_xe_hpc_core
+         ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_lib_tests_xe_hpc_core.cpp
+    )
+  endif()
+
+  target_sources(${TARGET_NAME} PRIVATE ${NEO_SHARED_tests_xe_hpc_core})
   add_subdirectories()
 endif()

shared/test/unit_test/xe_hpc_core/aub_center_using_aubstream_lib_tests_xe_hpc_core.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/gmm_helper/gmm_helper.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/mocks/mock_aub_center.h"
+#include "shared/test/common/test_macros/test.h"
+using namespace NEO;
+using XeHpcCoreAubCenterTests = ::testing::Test;
+
+XE_HPC_CORETEST_F(XeHpcCoreAubCenterTests, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenAubCenterCreatesAubManager) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+
+    EXPECT_NE(nullptr, aubCenter.aubManager.get());
+}

shared/test/unit_test/xe_hpg_core/CMakeLists.txt

@@ -5,9 +5,16 @@
 #
 
 if(TESTS_XE_HPG_CORE)
-  target_sources(neo_shared_tests PRIVATE
-                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpg_core_tests.cpp
+  set(NEO_SHARED_tests_xe_hpg_core
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpg_core_tests.cpp
   )
+
+  if(DEFINED AUB_STREAM_PROJECT_NAME)
+    list(APPEND NEO_SHARED_tests_xe_hpg_core
+         ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_lib_tests_xe_hpg_core.cpp
+    )
+  endif()
+  target_sources(${TARGET_NAME} PRIVATE ${NEO_SHARED_tests_xe_hpg_core})
   add_subdirectories()
 endif()

shared/test/unit_test/xe_hpg_core/aub_center_using_aubstream_lib_tests_xe_hpg_core.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/gmm_helper/gmm_helper.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/mocks/mock_aub_center.h"
+#include "shared/test/common/test_macros/test.h"
+using namespace NEO;
+using XeHpgCoreAubCenterTests = ::testing::Test;
+
+XE_HPG_CORETEST_F(XeHpgCoreAubCenterTests, GivenUseAubStreamDebugVariableSetWhenAubCenterIsCreatedThenAubCenterCreatesAubManager) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.UseAubStream.set(true);
+
+    GmmHelper gmmHelper(nullptr, defaultHwInfo.get());
+
+    MockAubCenter aubCenter(defaultHwInfo.get(), gmmHelper, false, "", CommandStreamReceiverType::CSR_AUB);
+
+    EXPECT_NE(nullptr, aubCenter.aubManager.get());
+}