Refactor and test initialization of IGC in ocloc

This change:
- encapsulates initialization of IGC in a separate class
- removes code duplication from OfflineLinker and OfflineCompiler
- tests the new encapsulated class

Related-To: NEO-6834
Signed-off-by: Patryk Wrobel <patryk.wrobel@intel.com>

opencl/test/unit_test/offline_compiler/CMakeLists.txt

@@ -20,6 +20,7 @@ set(IGDRCL_SRCS_offline_compiler_mock
     ${CMAKE_CURRENT_SOURCE_DIR}/decoder/mock/mock_iga_wrapper.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_argument_helper.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_multi_command.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_ocloc_igc_facade.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_offline_compiler.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_offline_linker.h
     ${CMAKE_CURRENT_SOURCE_DIR}/mock/mock_sip_ocloc_tests.cpp
@@ -57,6 +58,8 @@ set(IGDRCL_SRCS_offline_compiler_tests
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_api_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_fatbinary_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_fatbinary_tests.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_igc_facade_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_igc_facade_tests.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_product_config_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_product_config_tests.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ocloc_tests_configuration.cpp

opencl/test/unit_test/offline_compiler/mock/mock_ocloc_igc_facade.h

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/offline_compiler/source/ocloc_igc_facade.h"
+
+#include <optional>
+#include <string>
+
+namespace NEO {
+
+class MockOclocIgcFacade : public OclocIgcFacade {
+  public:
+    using OclocIgcFacade::igcDeviceCtx;
+
+    bool shouldFailLoadingOfIgcLib{false};
+    bool shouldFailLoadingOfIgcCreateMainFunction{false};
+    bool shouldFailCreationOfIgcMain{false};
+    bool shouldFailCreationOfIgcDeviceContext{false};
+    bool shouldReturnInvalidIgcPlatformHandle{false};
+    bool shouldReturnInvalidGTSystemInfoHandle{false};
+    bool shouldReturnInvalidIgcFeaturesAndWorkaroundsHandle{false};
+    std::optional<bool> isIgcInterfaceCompatibleReturnValue{};
+    std::optional<std::string> getIncompatibleInterfaceReturnValue{};
+    std::optional<bool> isPatchtokenInterfaceSupportedReturnValue{};
+
+    MockOclocIgcFacade(OclocArgHelper *argHelper) : OclocIgcFacade{argHelper} {}
+    ~MockOclocIgcFacade() override = default;
+
+    std::unique_ptr<OsLibrary> loadIgcLibrary() const override {
+        if (shouldFailLoadingOfIgcLib) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::loadIgcLibrary();
+        }
+    }
+
+    CIF::CreateCIFMainFunc_t loadCreateIgcMainFunction() const override {
+        if (shouldFailLoadingOfIgcCreateMainFunction) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::loadCreateIgcMainFunction();
+        }
+    }
+
+    CIF::RAII::UPtr_t<CIF::CIFMain> createIgcMain(CIF::CreateCIFMainFunc_t createMainFunction) const override {
+        if (shouldFailCreationOfIgcMain) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::createIgcMain(createMainFunction);
+        }
+    }
+
+    bool isIgcInterfaceCompatible(const std::vector<CIF::InterfaceId_t> &interfacesToIgnore) const override {
+        if (isIgcInterfaceCompatibleReturnValue.has_value()) {
+            return *isIgcInterfaceCompatibleReturnValue;
+        } else {
+            return OclocIgcFacade::isIgcInterfaceCompatible(interfacesToIgnore);
+        }
+    }
+
+    std::string getIncompatibleInterface(const std::vector<CIF::InterfaceId_t> &interfacesToIgnore) const override {
+        if (getIncompatibleInterfaceReturnValue.has_value()) {
+            return *getIncompatibleInterfaceReturnValue;
+        } else {
+            return OclocIgcFacade::getIncompatibleInterface(interfacesToIgnore);
+        }
+    }
+
+    bool isPatchtokenInterfaceSupported() const override {
+        if (isPatchtokenInterfaceSupportedReturnValue.has_value()) {
+            return *isPatchtokenInterfaceSupportedReturnValue;
+        } else {
+            return OclocIgcFacade::isPatchtokenInterfaceSupported();
+        }
+    }
+
+    CIF::RAII::UPtr_t<IGC::IgcOclDeviceCtxTagOCL> createIgcDeviceContext() const override {
+        if (shouldFailCreationOfIgcDeviceContext) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::createIgcDeviceContext();
+        }
+    }
+
+    CIF::RAII::UPtr_t<IGC::PlatformTagOCL> getIgcPlatformHandle() const override {
+        if (shouldReturnInvalidIgcPlatformHandle) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::getIgcPlatformHandle();
+        }
+    }
+
+    CIF::RAII::UPtr_t<IGC::GTSystemInfoTagOCL> getGTSystemInfoHandle() const override {
+        if (shouldReturnInvalidGTSystemInfoHandle) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::getGTSystemInfoHandle();
+        }
+    }
+
+    CIF::RAII::UPtr_t<IGC::IgcFeaturesAndWorkaroundsTagOCL> getIgcFeaturesAndWorkaroundsHandle() const override {
+        if (shouldReturnInvalidIgcFeaturesAndWorkaroundsHandle) {
+            return nullptr;
+        } else {
+            return OclocIgcFacade::getIgcFeaturesAndWorkaroundsHandle();
+        }
+    }
+};
+
+} // namespace NEO

opencl/test/unit_test/offline_compiler/mock/mock_offline_compiler.h

@@ -10,6 +10,7 @@
 #include "shared/offline_compiler/source/offline_compiler.h"
 
 #include "opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h"
+#include "opencl/test/unit_test/offline_compiler/mock/mock_ocloc_igc_facade.h"
 
 #include <optional>
 #include <string>
@@ -32,7 +33,7 @@ class MockOfflineCompiler : public OfflineCompiler {
     using OfflineCompiler::generateOptsSuffix;
     using OfflineCompiler::getStringWithinDelimiters;
     using OfflineCompiler::hwInfo;
-    using OfflineCompiler::igcDeviceCtx;
+    using OfflineCompiler::igcFacade;
     using OfflineCompiler::initHardwareInfo;
     using OfflineCompiler::inputFile;
     using OfflineCompiler::inputFileLlvm;
@@ -60,7 +61,12 @@ class MockOfflineCompiler : public OfflineCompiler {
         uniqueHelper = std::make_unique<MockOclocArgHelper>(filesMap);
         uniqueHelper->setAllCallBase(true);
         argHelper = uniqueHelper.get();
+
+        auto uniqueIgcFacadeMock = std::make_unique<MockOclocIgcFacade>(argHelper);
+        mockIgcFacade = uniqueIgcFacadeMock.get();
+        igcFacade = std::move(uniqueIgcFacadeMock);
     }
+
     ~MockOfflineCompiler() override = default;
 
     int initialize(size_t numArgs, const std::vector<std::string> &argv) {
@@ -118,6 +124,7 @@ class MockOfflineCompiler : public OfflineCompiler {
     uint32_t generateElfBinaryCalled = 0u;
     uint32_t writeOutAllFilesCalled = 0u;
     std::unique_ptr<MockOclocArgHelper> uniqueHelper;
+    MockOclocIgcFacade *mockIgcFacade = nullptr;
     int buildCalledCount{0};
     std::optional<int> buildReturnValue{};
     bool interceptCreatedDirs{false};

opencl/test/unit_test/offline_compiler/mock/mock_offline_linker.h

@@ -20,7 +20,6 @@ class MockOfflineLinker : public OfflineLinker {
     using OfflineLinker::initialize;
     using OfflineLinker::loadInputFilesContent;
     using OfflineLinker::parseCommand;
-    using OfflineLinker::prepareIgc;
     using OfflineLinker::tryToStoreBuildLog;
     using OfflineLinker::verifyLinkerCommand;
 
@@ -34,14 +33,9 @@ class MockOfflineLinker : public OfflineLinker {
     using OfflineLinker::outputFormat;
 
     bool shouldReturnEmptyHardwareInfoTable{false};
-    bool shouldFailLoadingOfIgcLib{false};
-    bool shouldFailLoadingOfIgcCreateMainFunction{false};
-    bool shouldFailCreationOfIgcMain{false};
-    bool shouldFailCreationOfIgcDeviceContext{false};
-    bool shouldReturnInvalidIgcPlatformHandle{false};
-    bool shouldReturnInvalidGTSystemInfoHandle{false};
 
-    MockOfflineLinker(OclocArgHelper *argHelper) : OfflineLinker{argHelper} {}
+    MockOfflineLinker(OclocArgHelper *argHelper, std::unique_ptr<OclocIgcFacade> igcFacade)
+        : OfflineLinker{argHelper, std::move(igcFacade)} {}
 
     ArrayRef<const HardwareInfo *> getHardwareInfoTable() const override {
         if (shouldReturnEmptyHardwareInfoTable) {
@@ -50,54 +44,6 @@ class MockOfflineLinker : public OfflineLinker {
             return OfflineLinker::getHardwareInfoTable();
         }
     }
-
-    std::unique_ptr<OsLibrary> loadIgcLibrary() const override {
-        if (shouldFailLoadingOfIgcLib) {
-            return nullptr;
-        } else {
-            return OfflineLinker::loadIgcLibrary();
-        }
-    }
-
-    CIF::CreateCIFMainFunc_t loadCreateIgcMainFunction() const override {
-        if (shouldFailLoadingOfIgcCreateMainFunction) {
-            return nullptr;
-        } else {
-            return OfflineLinker::loadCreateIgcMainFunction();
-        }
-    }
-
-    CIF::RAII::UPtr_t<CIF::CIFMain> createIgcMain(CIF::CreateCIFMainFunc_t createMainFunction) const override {
-        if (shouldFailCreationOfIgcMain) {
-            return nullptr;
-        } else {
-            return OfflineLinker::createIgcMain(createMainFunction);
-        }
-    }
-
-    CIF::RAII::UPtr_t<IGC::IgcOclDeviceCtxTagOCL> createIgcDeviceContext() const override {
-        if (shouldFailCreationOfIgcDeviceContext) {
-            return nullptr;
-        } else {
-            return OfflineLinker::createIgcDeviceContext();
-        }
-    }
-
-    CIF::RAII::UPtr_t<IGC::PlatformTagOCL> getIgcPlatformHandle() const override {
-        if (shouldReturnInvalidIgcPlatformHandle) {
-            return nullptr;
-        } else {
-            return OfflineLinker::getIgcPlatformHandle();
-        }
-    }
-
-    CIF::RAII::UPtr_t<IGC::GTSystemInfoTagOCL> getGTSystemInfoHandle() const override {
-        if (shouldReturnInvalidGTSystemInfoHandle) {
-            return nullptr;
-        } else {
-            return OfflineLinker::getGTSystemInfoHandle();
-        }
-    }
 };
 
 } // namespace NEO

opencl/test/unit_test/offline_compiler/ocloc_igc_facade_tests.cpp

@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "ocloc_igc_facade_tests.h"
+
+#include "shared/offline_compiler/source/ocloc_error_code.h"
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/os_interface/os_inc_base.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+
+#include "mock/mock_ocloc_igc_facade.h"
+
+#include <string>
+
+namespace NEO {
+
+TEST_F(OclocIgcFacadeTest, GivenMissingIgcLibraryWhenPreparingIgcThenFailureIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.shouldFailLoadingOfIgcLib = true;
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    std::stringstream expectedErrorMessage;
+    expectedErrorMessage << "Error! Loading of IGC library has failed! Filename: " << Os::igcDllName << "\n";
+
+    EXPECT_EQ(expectedErrorMessage.str(), output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenFailingLoadingOfIgcSymbolsWhenPreparingIgcThenFailureIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.shouldFailLoadingOfIgcCreateMainFunction = true;
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    const std::string expectedErrorMessage{"Error! Cannot load required functions from IGC library.\n"};
+    EXPECT_EQ(expectedErrorMessage, output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenFailingCreationOfIgcMainWhenPreparingIgcThenFailureIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.shouldFailCreationOfIgcMain = true;
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    const std::string expectedErrorMessage{"Error! Cannot create IGC main component!\n"};
+    EXPECT_EQ(expectedErrorMessage, output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenIncompatibleIgcInterfacesWhenPreparingIgcThenFailureIsReported) {
+    DebugManagerStateRestore stateRestore;
+    DebugManager.flags.EnableDebugBreak.set(false);
+
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.isIgcInterfaceCompatibleReturnValue = false;
+    mockIgcFacade.getIncompatibleInterfaceReturnValue = "SomeImportantInterface";
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    const std::string expectedErrorMessage{"Error! Incompatible interface in IGC: SomeImportantInterface\n"};
+    EXPECT_EQ(expectedErrorMessage, output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenMissingPatchtokenInterfaceWhenPreparingIgcThenFailureIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.isPatchtokenInterfaceSupportedReturnValue = false;
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    const std::string expectedErrorMessage{"Error! Patchtoken interface is missing.\n"};
+    EXPECT_EQ(expectedErrorMessage, output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenFailingCreationOfIgcDeviceContextWhenPreparingIgcThenFailureIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+    mockIgcFacade.shouldFailCreationOfIgcDeviceContext = true;
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+    EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+    const std::string expectedErrorMessage{"Error! Cannot create IGC device context!\n"};
+    EXPECT_EQ(expectedErrorMessage, output);
+}
+
+TEST_F(OclocIgcFacadeTest, GivenInvalidIgcDeviceContextWhenPreparingIgcThenFailureIsReported) {
+    constexpr std::array invalidReturnFlags = {
+        &MockOclocIgcFacade::shouldReturnInvalidIgcPlatformHandle,
+        &MockOclocIgcFacade::shouldReturnInvalidGTSystemInfoHandle,
+        &MockOclocIgcFacade::shouldReturnInvalidIgcFeaturesAndWorkaroundsHandle};
+
+    for (const auto &invalidReturnFlag : invalidReturnFlags) {
+        MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+        mockIgcFacade.*invalidReturnFlag = true;
+
+        ::testing::internal::CaptureStdout();
+        const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+        const auto output{::testing::internal::GetCapturedStdout()};
+
+        EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
+        EXPECT_FALSE(mockIgcFacade.isInitialized());
+
+        const std::string expectedErrorMessage{"Error! IGC device context has not been properly created!\n"};
+        EXPECT_EQ(expectedErrorMessage, output);
+    }
+}
+
+TEST_F(OclocIgcFacadeTest, GivenNoneErrorsSetWhenPreparingIgcThenSuccessIsReported) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    EXPECT_EQ(OclocErrorCode::SUCCESS, igcPreparationResult);
+    EXPECT_TRUE(output.empty()) << output;
+    EXPECT_TRUE(mockIgcFacade.isInitialized());
+}
+
+TEST_F(OclocIgcFacadeTest, GivenInitializedIgcWhenGettingIncompatibleInterfaceThenEmptyStringIsReturned) {
+    MockOclocIgcFacade mockIgcFacade{&mockArgHelper};
+
+    ::testing::internal::CaptureStdout();
+    const auto igcPreparationResult{mockIgcFacade.initialize(hwInfo)};
+    const auto output{::testing::internal::GetCapturedStdout()};
+
+    ASSERT_EQ(OclocErrorCode::SUCCESS, igcPreparationResult);
+
+    const std::vector<CIF::InterfaceId_t> interfacesToIgnore{};
+    const auto incompatibleInterface = mockIgcFacade.getIncompatibleInterface(interfacesToIgnore);
+
+    EXPECT_TRUE(incompatibleInterface.empty()) << incompatibleInterface;
+}
+
+} // namespace NEO

opencl/test/unit_test/offline_compiler/ocloc_igc_facade_tests.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/source/helpers/hw_info.h"
+
+#include "gtest/gtest.h"
+#include "mock/mock_argument_helper.h"
+
+namespace NEO {
+
+class OclocIgcFacadeTest : public ::testing::Test {
+  protected:
+    MockOclocArgHelper::FilesMap mockArgHelperFilesMap{};
+    MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap};
+    HardwareInfo hwInfo{};
+};
+
+} // namespace NEO

opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp

@@ -956,6 +956,29 @@ TEST_F(OfflineCompilerTests, givenExcludeIrFromZebinInternalOptionWhenInitIsPerf
     EXPECT_TRUE(mockOfflineCompiler.excludeIr);
 }
 
+TEST_F(OfflineCompilerTests, givenValidArgumentsAndIgcInitFailureWhenInitIsPerformedThenFailureIsPropagatedAndErrorIsPrinted) {
+    std::vector<std::string> argv = {
+        "ocloc",
+        "-file",
+        "test_files/copybuffer.cl",
+        "-device",
+        gEnvironment->devicePrefix.c_str()};
+
+    MockOfflineCompiler mockOfflineCompiler{};
+    mockOfflineCompiler.mockIgcFacade->shouldFailLoadingOfIgcLib = true;
+
+    testing::internal::CaptureStdout();
+    const auto initResult = mockOfflineCompiler.initialize(argv.size(), argv);
+    const auto output = testing::internal::GetCapturedStdout();
+
+    std::stringstream expectedErrorMessage;
+    expectedErrorMessage << "Error! Loading of IGC library has failed! Filename: " << Os::igcDllName << "\n"
+                         << "Error! IGC initialization failure. Error code = -6\n";
+
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, initResult);
+    EXPECT_EQ(expectedErrorMessage.str(), output);
+}
+
 TEST_F(OfflineCompilerTests, givenExcludeIrArgumentWhenInitIsPerformedThenIrExcludeFlagsShouldBeUnified) {
     std::vector<std::string> argv = {
         "ocloc",
@@ -1333,7 +1356,7 @@ TEST_F(OfflineCompilerTests, WhenFclNotNeededThenDontLoadIt) {
     auto ret = offlineCompiler.initialize(argv.size(), argv);
     EXPECT_EQ(0, ret);
     EXPECT_EQ(nullptr, offlineCompiler.fclDeviceCtx);
-    EXPECT_NE(nullptr, offlineCompiler.igcDeviceCtx);
+    EXPECT_TRUE(offlineCompiler.igcFacade->isInitialized());
 }
 
 TEST_F(OfflineCompilerTests, WhenParsingBinToCharArrayThenCorrectResult) {
@@ -1981,7 +2004,7 @@ TEST(OfflineCompilerTest, givenIntermediateRepresentationInputWhenBuildSourceCod
     testing::internal::CaptureStdout();
     auto retVal = mockOfflineCompiler.initialize(argv.size(), argv);
     auto mockIgcOclDeviceCtx = new NEO::MockIgcOclDeviceCtx();
-    mockOfflineCompiler.igcDeviceCtx = CIF::RAII::Pack<IGC::IgcOclDeviceCtxTagOCL>(mockIgcOclDeviceCtx);
+    mockOfflineCompiler.mockIgcFacade->igcDeviceCtx = CIF::RAII::Pack<IGC::IgcOclDeviceCtxTagOCL>(mockIgcOclDeviceCtx);
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     mockOfflineCompiler.inputFileSpirV = true;
@@ -2067,7 +2090,7 @@ TEST(OfflineCompilerTest, givenSpirvInputFileWhenCmdLineHasOptionsThenCorrectOpt
 
     auto retVal = mockOfflineCompiler.initialize(argv.size(), argv);
     auto mockIgcOclDeviceCtx = new NEO::MockIgcOclDeviceCtx();
-    mockOfflineCompiler.igcDeviceCtx = CIF::RAII::Pack<IGC::IgcOclDeviceCtxTagOCL>(mockIgcOclDeviceCtx);
+    mockOfflineCompiler.mockIgcFacade->igcDeviceCtx = CIF::RAII::Pack<IGC::IgcOclDeviceCtxTagOCL>(mockIgcOclDeviceCtx);
     ASSERT_EQ(CL_SUCCESS, retVal);
 
     mockOfflineCompiler.inputFileSpirV = true;

opencl/test/unit_test/offline_compiler/offline_linker_tests.cpp

@@ -65,7 +65,7 @@ MockOfflineLinker::InputFileContent OfflineLinkerTest::createFileContent(const s
 }
 
 TEST_F(OfflineLinkerTest, GivenDefaultConstructedLinkerThenRequiredFieldsHaveDefaultValues) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     EXPECT_EQ(OperationMode::SKIP_EXECUTION, mockOfflineLinker.operationMode);
     EXPECT_EQ("linker_output", mockOfflineLinker.outputFilename);
@@ -76,7 +76,7 @@ TEST_F(OfflineLinkerTest, GivenLessThanTwoArgumentsWhenParsingThenInvalidCommand
     const std::vector<std::string> argv = {
         "ocloc.exe"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
     EXPECT_EQ(OclocErrorCode::INVALID_COMMAND_LINE, result);
 }
@@ -93,7 +93,7 @@ TEST_F(OfflineLinkerTest, GivenInputFilesArgumentsWhenParsingThenListOfFilenames
         "-file",
         secondFile};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -112,7 +112,7 @@ TEST_F(OfflineLinkerTest, GivenOutputFilenameArgumentWhenParsingThenOutputFilena
         "-out",
         outputFilename};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -126,7 +126,7 @@ TEST_F(OfflineLinkerTest, GivenValidOutputFileFormatWhenParsingThenOutputFormatI
         "-out_format",
         "LLVM_BC"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -140,7 +140,7 @@ TEST_F(OfflineLinkerTest, GivenUnknownOutputFileFormatWhenParsingThenInvalidForm
         "-out_format",
         "StrangeFormat"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -156,7 +156,7 @@ TEST_F(OfflineLinkerTest, GivenOptionsArgumentWhenParsingThenOptionsAreSet) {
         "-options",
         options};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -172,7 +172,7 @@ TEST_F(OfflineLinkerTest, GivenInternalOptionsArgumentWhenParsingThenInternalOpt
         "-internal_options",
         internalOptions};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -185,7 +185,7 @@ TEST_F(OfflineLinkerTest, GivenHelpArgumentWhenParsingThenShowHelpOperationIsSet
         "link",
         "--help"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
 
     ASSERT_EQ(OclocErrorCode::SUCCESS, result);
@@ -199,7 +199,7 @@ TEST_F(OfflineLinkerTest, GivenUnknownArgumentWhenParsingThenErrorIsReported) {
         "-some_new_unknown_command"};
 
     ::testing::internal::CaptureStdout();
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto result = mockOfflineLinker.initialize(argv.size(), argv);
     const auto output{::testing::internal::GetCapturedStdout()};
 
@@ -219,7 +219,8 @@ TEST_F(OfflineLinkerTest, GivenFlagsWhichRequireMoreArgsWithoutThemWhenParsingTh
             "link",
             flag};
 
-        MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+        mockOclocIgcFacade = std::make_unique<MockOclocIgcFacade>(&mockArgHelper);
+        MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
         ::testing::internal::CaptureStdout();
         const auto result = mockOfflineLinker.parseCommand(argv.size(), argv);
@@ -233,7 +234,7 @@ TEST_F(OfflineLinkerTest, GivenFlagsWhichRequireMoreArgsWithoutThemWhenParsingTh
 }
 
 TEST_F(OfflineLinkerTest, GivenCommandWithoutInputFilesWhenVerificationIsPerformedThenErrorIsReturned) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilenames = {};
 
     ::testing::internal::CaptureStdout();
@@ -253,7 +254,7 @@ TEST_F(OfflineLinkerTest, GivenCommandWithEmptyFilenameWhenVerificationIsPerform
         "-file",
         ""};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     ::testing::internal::CaptureStdout();
     const auto verificationResult = mockOfflineLinker.initialize(argv.size(), argv);
@@ -274,7 +275,7 @@ TEST_F(OfflineLinkerTest, GivenCommandWithNonexistentInputFileWhenVerificationIs
         "-file",
         "some_file2.spv"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto parsingResult = mockOfflineLinker.parseCommand(argv.size(), argv);
     ASSERT_EQ(OclocErrorCode::SUCCESS, parsingResult);
 
@@ -299,7 +300,7 @@ TEST_F(OfflineLinkerTest, GivenCommandWithInvalidOutputFormatWhenVerificationIsP
         "-out_format",
         "SomeDummyUnknownFormat"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto parsingResult = mockOfflineLinker.parseCommand(argv.size(), argv);
     ASSERT_EQ(OclocErrorCode::SUCCESS, parsingResult);
 
@@ -325,7 +326,7 @@ TEST_F(OfflineLinkerTest, GivenValidCommandWhenVerificationIsPerformedThenSucces
         "-file",
         "some_file2.spv"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     const auto parsingResult = mockOfflineLinker.parseCommand(argv.size(), argv);
     ASSERT_EQ(OclocErrorCode::SUCCESS, parsingResult);
 
@@ -348,13 +349,13 @@ TEST_F(OfflineLinkerTest, GivenEmptyFileWhenLoadingInputFilesThenErrorIsReturned
         "-file",
         filename};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     ::testing::internal::CaptureStdout();
-    const auto readingResult = mockOfflineLinker.initialize(argv.size(), argv);
+    const auto initializationResult = mockOfflineLinker.initialize(argv.size(), argv);
     const auto output{::testing::internal::GetCapturedStdout()};
 
-    ASSERT_EQ(OclocErrorCode::INVALID_FILE, readingResult);
+    ASSERT_EQ(OclocErrorCode::INVALID_FILE, initializationResult);
 
     const std::string expectedErrorMessage{"Error: Cannot read input file: some_file.spv\n"};
     EXPECT_EQ(expectedErrorMessage, output);
@@ -366,7 +367,7 @@ TEST_F(OfflineLinkerTest, GivenValidFileWithUnknownFormatWhenLoadingInputFilesTh
     // Spir-V or LLVM-BC magic constants are required. This should be treated as error.
     mockArgHelperFilesMap[filename] = "Some unknown format!";
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilenames.push_back(filename);
 
     ::testing::internal::CaptureStdout();
@@ -386,7 +387,7 @@ TEST_F(OfflineLinkerTest, GivenValidFilesWithValidFormatsWhenLoadingInputFilesTh
     mockArgHelperFilesMap[firstFilename] = getEmptySpirvFile();
     mockArgHelperFilesMap[secondFilename] = getEmptyLlvmBcFile();
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilenames.push_back(firstFilename);
     mockOfflineLinker.inputFilenames.push_back(secondFilename);
 
@@ -427,13 +428,13 @@ TEST_F(OfflineLinkerTest, GivenValidFilesWhenInitializationIsSuccessfulThenLinkM
         "-file",
         secondFilename};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     ::testing::internal::CaptureStdout();
-    const auto readingResult = mockOfflineLinker.initialize(argv.size(), argv);
+    const auto initializationResult = mockOfflineLinker.initialize(argv.size(), argv);
     const auto output{::testing::internal::GetCapturedStdout()};
 
-    EXPECT_EQ(OclocErrorCode::SUCCESS, readingResult);
+    EXPECT_EQ(OclocErrorCode::SUCCESS, initializationResult);
     EXPECT_TRUE(output.empty());
 
     EXPECT_EQ(OperationMode::LINK_FILES, mockOfflineLinker.operationMode);
@@ -445,7 +446,7 @@ TEST_F(OfflineLinkerTest, GivenSPIRVandLLVMBCFilesWhenElfOutputIsRequestedThenEl
 
     mockArgHelper.interceptOutput = true;
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(spirvFileContent.bytes), spirvFileContent.size, spirvFileContent.codeType);
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(llvmbcFileContent.bytes), llvmbcFileContent.size, llvmbcFileContent.codeType);
     mockOfflineLinker.outputFormat = IGC::CodeType::elf;
@@ -492,15 +493,16 @@ TEST_F(OfflineLinkerTest, GivenValidInputFileContentsWhenLlvmBcOutputIsRequested
 
     mockArgHelper.interceptOutput = true;
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    HardwareInfo hwInfo{};
+    const auto igcInitializationResult{mockOclocIgcFacade->initialize(hwInfo)};
+    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
+
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(spirvFileContent.bytes), spirvFileContent.size, spirvFileContent.codeType);
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(llvmbcFileContent.bytes), llvmbcFileContent.size, llvmbcFileContent.codeType);
     mockOfflineLinker.outputFormat = IGC::CodeType::llvmBc;
     mockOfflineLinker.operationMode = OperationMode::LINK_FILES;
 
-    const auto igcInitializationResult{mockOfflineLinker.prepareIgc()};
-    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
-
     const auto linkingResult{mockOfflineLinker.execute()};
     ASSERT_EQ(OclocErrorCode::SUCCESS, linkingResult);
 
@@ -524,15 +526,16 @@ TEST_F(OfflineLinkerTest, GivenValidInputFileContentsAndFailingIGCWhenLlvmBcOutp
 
     mockArgHelper.interceptOutput = true;
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    HardwareInfo hwInfo{};
+    const auto igcInitializationResult{mockOclocIgcFacade->initialize(hwInfo)};
+    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
+
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(spirvFileContent.bytes), spirvFileContent.size, spirvFileContent.codeType);
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(llvmbcFileContent.bytes), llvmbcFileContent.size, llvmbcFileContent.codeType);
     mockOfflineLinker.outputFormat = IGC::CodeType::llvmBc;
     mockOfflineLinker.operationMode = OperationMode::LINK_FILES;
 
-    const auto igcInitializationResult{mockOfflineLinker.prepareIgc()};
-    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
-
     ::testing::internal::CaptureStdout();
     const auto linkingResult{mockOfflineLinker.execute()};
     const auto output{::testing::internal::GetCapturedStdout()};
@@ -554,15 +557,16 @@ TEST_F(OfflineLinkerTest, GivenValidInputFileContentsAndInvalidTranslationOutput
 
     mockArgHelper.interceptOutput = true;
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    HardwareInfo hwInfo{};
+    const auto igcInitializationResult{mockOclocIgcFacade->initialize(hwInfo)};
+    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
+
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(spirvFileContent.bytes), spirvFileContent.size, spirvFileContent.codeType);
     mockOfflineLinker.inputFilesContent.emplace_back(std::move(llvmbcFileContent.bytes), llvmbcFileContent.size, llvmbcFileContent.codeType);
     mockOfflineLinker.outputFormat = IGC::CodeType::llvmBc;
     mockOfflineLinker.operationMode = OperationMode::LINK_FILES;
 
-    const auto igcInitializationResult{mockOfflineLinker.prepareIgc()};
-    ASSERT_EQ(OclocErrorCode::SUCCESS, igcInitializationResult);
-
     ::testing::internal::CaptureStdout();
     const auto linkingResult{mockOfflineLinker.execute()};
     const auto output{::testing::internal::GetCapturedStdout()};
@@ -575,7 +579,7 @@ TEST_F(OfflineLinkerTest, GivenValidInputFileContentsAndInvalidTranslationOutput
 }
 
 TEST_F(OfflineLinkerTest, GivenUninitializedLinkerWhenExecuteIsInvokedThenErrorIsIssued) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     ::testing::internal::CaptureStdout();
     const auto executionResult{mockOfflineLinker.execute()};
@@ -586,7 +590,7 @@ TEST_F(OfflineLinkerTest, GivenUninitializedLinkerWhenExecuteIsInvokedThenErrorI
 }
 
 TEST_F(OfflineLinkerTest, GivenHelpRequestWhenExecuteIsInvokedThenHelpIsPrinted) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.operationMode = OperationMode::SHOW_HELP;
 
     ::testing::internal::CaptureStdout();
@@ -598,7 +602,7 @@ TEST_F(OfflineLinkerTest, GivenHelpRequestWhenExecuteIsInvokedThenHelpIsPrinted)
 }
 
 TEST_F(OfflineLinkerTest, GivenInvalidOperationModeWhenExecuteIsInvokedThenErrorIsIssued) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.operationMode = static_cast<OperationMode>(7);
 
     ::testing::internal::CaptureStdout();
@@ -610,7 +614,7 @@ TEST_F(OfflineLinkerTest, GivenInvalidOperationModeWhenExecuteIsInvokedThenError
 }
 
 TEST_F(OfflineLinkerTest, GivenUninitializedHwInfoWhenInitIsCalledThenHwInfoIsInitialized) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     ASSERT_EQ(IGFX_UNKNOWN, mockOfflineLinker.hwInfo.platform.eProductFamily);
 
     const auto hwInfoInitializationResult{mockOfflineLinker.initHardwareInfo()};
@@ -633,14 +637,14 @@ TEST_F(OfflineLinkerTest, GivenEmptyHwInfoTableWhenInitializationIsPerformedThen
         "-file",
         secondFilename};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.shouldReturnEmptyHardwareInfoTable = true;
 
     ::testing::internal::CaptureStdout();
-    const auto readingResult = mockOfflineLinker.initialize(argv.size(), argv);
+    const auto initializationResult = mockOfflineLinker.initialize(argv.size(), argv);
     const auto output{::testing::internal::GetCapturedStdout()};
 
-    EXPECT_EQ(OclocErrorCode::INVALID_DEVICE, readingResult);
+    EXPECT_EQ(OclocErrorCode::INVALID_DEVICE, initializationResult);
 
     const std::string expectedErrorMessage{"Error! Cannot retrieve any valid hardware information!\n"};
     EXPECT_EQ(expectedErrorMessage, output);
@@ -661,14 +665,14 @@ TEST_F(OfflineLinkerTest, GivenMissingIgcLibraryWhenInitializationIsPerformedThe
         "-file",
         secondFilename};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldFailLoadingOfIgcLib = true;
+    mockOclocIgcFacade->shouldFailLoadingOfIgcLib = true;
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
 
     ::testing::internal::CaptureStdout();
-    const auto readingResult = mockOfflineLinker.initialize(argv.size(), argv);
+    const auto initializationResult = mockOfflineLinker.initialize(argv.size(), argv);
     const auto output{::testing::internal::GetCapturedStdout()};
 
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, readingResult);
+    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, initializationResult);
 
     std::stringstream expectedErrorMessage;
     expectedErrorMessage << "Error! Loading of IGC library has failed! Filename: " << Os::igcDllName << "\n";
@@ -679,14 +683,14 @@ TEST_F(OfflineLinkerTest, GivenMissingIgcLibraryWhenInitializationIsPerformedThe
 TEST_F(OfflineLinkerTest, GivenOfflineLinkerWhenStoringValidBuildLogThenItIsSaved) {
     const std::string someValidLog{"Warning: This is a build log!"};
 
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.tryToStoreBuildLog(someValidLog.data(), someValidLog.size());
 
     EXPECT_EQ(someValidLog, mockOfflineLinker.getBuildLog());
 }
 
 TEST_F(OfflineLinkerTest, GivenOfflineLinkerWhenStoringInvalidBuildLogThenItIsIgnored) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
+    MockOfflineLinker mockOfflineLinker{&mockArgHelper, std::move(mockOclocIgcFacade)};
     mockOfflineLinker.tryToStoreBuildLog(nullptr, 0);
 
     const auto buildLog{mockOfflineLinker.getBuildLog()};
@@ -700,74 +704,4 @@ TEST_F(OfflineLinkerTest, GivenOfflineLinkerWhenStoringInvalidBuildLogThenItIsIg
     EXPECT_TRUE(buildLog2.empty());
 }
 
-TEST_F(OfflineLinkerTest, GivenFailingLoadingOfIgcSymbolsWhenPreparingIgcThenFailureIsReported) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldFailLoadingOfIgcCreateMainFunction = true;
-
-    ::testing::internal::CaptureStdout();
-    const auto igcPreparationResult{mockOfflineLinker.prepareIgc()};
-    const auto output{::testing::internal::GetCapturedStdout()};
-
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
-
-    const std::string expectedErrorMessage{"Error! Cannot load required functions from IGC library.\n"};
-    EXPECT_EQ(expectedErrorMessage, output);
-}
-
-TEST_F(OfflineLinkerTest, GivenFailingCreationOfIgcMainWhenPreparingIgcThenFailureIsReported) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldFailCreationOfIgcMain = true;
-
-    ::testing::internal::CaptureStdout();
-    const auto igcPreparationResult{mockOfflineLinker.prepareIgc()};
-    const auto output{::testing::internal::GetCapturedStdout()};
-
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
-
-    const std::string expectedErrorMessage{"Error! Cannot create IGC main component!\n"};
-    EXPECT_EQ(expectedErrorMessage, output);
-}
-
-TEST_F(OfflineLinkerTest, GivenFailingCreationOfIgcDeviceContextWhenPreparingIgcThenFailureIsReported) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldFailCreationOfIgcDeviceContext = true;
-
-    ::testing::internal::CaptureStdout();
-    const auto igcPreparationResult{mockOfflineLinker.prepareIgc()};
-    const auto output{::testing::internal::GetCapturedStdout()};
-
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
-
-    const std::string expectedErrorMessage{"Error! Cannot create IGC device context!\n"};
-    EXPECT_EQ(expectedErrorMessage, output);
-}
-
-TEST_F(OfflineLinkerTest, GivenInvalidIgcPlatformHandleWhenPreparingIgcThenFailureIsReported) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldReturnInvalidIgcPlatformHandle = true;
-
-    ::testing::internal::CaptureStdout();
-    const auto igcPreparationResult{mockOfflineLinker.prepareIgc()};
-    const auto output{::testing::internal::GetCapturedStdout()};
-
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
-
-    const std::string expectedErrorMessage{"Error! IGC device context has not been properly created!\n"};
-    EXPECT_EQ(expectedErrorMessage, output);
-}
-
-TEST_F(OfflineLinkerTest, GivenInvalidIgcGTSystemInfoHandleWhenPreparingIgcThenFailureIsReported) {
-    MockOfflineLinker mockOfflineLinker{&mockArgHelper};
-    mockOfflineLinker.shouldReturnInvalidGTSystemInfoHandle = true;
-
-    ::testing::internal::CaptureStdout();
-    const auto igcPreparationResult{mockOfflineLinker.prepareIgc()};
-    const auto output{::testing::internal::GetCapturedStdout()};
-
-    EXPECT_EQ(OclocErrorCode::OUT_OF_HOST_MEMORY, igcPreparationResult);
-
-    const std::string expectedErrorMessage{"Error! IGC device context has not been properly created!\n"};
-    EXPECT_EQ(expectedErrorMessage, output);
-}
-
 } // namespace NEO

opencl/test/unit_test/offline_compiler/offline_linker_tests.h

@@ -9,12 +9,17 @@
 
 #include "gtest/gtest.h"
 #include "mock/mock_argument_helper.h"
+#include "mock/mock_ocloc_igc_facade.h"
 #include "mock/mock_offline_linker.h"
 
 namespace NEO {
 
 class OfflineLinkerTest : public ::testing::Test {
   public:
+    OfflineLinkerTest() {
+        mockOclocIgcFacade = std::make_unique<MockOclocIgcFacade>(&mockArgHelper);
+    }
+
     void SetUp() override;
     void TearDown() override;
 
@@ -25,6 +30,7 @@ class OfflineLinkerTest : public ::testing::Test {
   protected:
     MockOclocArgHelper::FilesMap mockArgHelperFilesMap{};
     MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap};
+    std::unique_ptr<MockOclocIgcFacade> mockOclocIgcFacade{};
     char binaryToReturn[8]{7, 7, 7, 7, 0, 1, 2, 3};
 };