refactor: add mock_aubstream

ArturHarasimiuk · Compute-Runtime-Automation · commit 6b0ffc5b93d0 · 2024-05-02T11:27:09.000+02:00
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com> Source: cbc868c
diff --git a/level_zero/CMakeLists.txt b/level_zero/CMakeLists.txt
@@ -231,10 +231,11 @@ if(BUILD_WITH_L0)
                    PRIVATE
                    ${NEO_SHARED_DIRECTORY}/aub/aub_stream_interface.cpp
     )
+    target_link_libraries(${TARGET_NAME_L0} PRIVATE ${AUB_STREAM_PROJECT_NAME})
   else()
     target_sources(${TARGET_NAME_L0}
                    PRIVATE
-                   ${NEO_SHARED_DIRECTORY}/aub/aub_stream_interface_stub.cpp
+                   $<TARGET_OBJECTS:aub_stream_stubs>
     )
 
   endif()
diff --git a/level_zero/core/test/aub_tests/CMakeLists.txt b/level_zero/core/test/aub_tests/CMakeLists.txt
@@ -72,6 +72,7 @@ if(NOT NEO_SKIP_AUB_TESTS AND DEFINED AUB_STREAM_PROJECT_NAME)
   target_link_libraries(${TARGET_NAME} ${HW_LIBS_ULT})
   target_link_libraries(${TARGET_NAME} gmock-gtest)
   target_link_libraries(${TARGET_NAME} ${NEO_EXTRA_LIBS})
+  target_link_libraries(${TARGET_NAME} ${AUB_STREAM_PROJECT_NAME})
 
   if(UNIX)
     target_link_libraries(${TARGET_NAME} rt)
diff --git a/level_zero/core/test/unit_tests/CMakeLists.txt b/level_zero/core/test/unit_tests/CMakeLists.txt
@@ -72,6 +72,7 @@ target_link_libraries(${TARGET_NAME}
 )
 
 target_sources(${TARGET_NAME} PRIVATE
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_fixtures>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>
diff --git a/level_zero/sysman/test/unit_tests/CMakeLists.txt b/level_zero/sysman/test/unit_tests/CMakeLists.txt
@@ -71,6 +71,7 @@ target_link_libraries(${TARGET_NAME}
 )
 
 target_sources(${TARGET_NAME} PRIVATE
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_fixtures>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>
diff --git a/level_zero/tools/test/unit_tests/CMakeLists.txt b/level_zero/tools/test/unit_tests/CMakeLists.txt
@@ -71,6 +71,7 @@ target_link_libraries(${TARGET_NAME}
 )
 
 target_sources(${TARGET_NAME} PRIVATE
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_fixtures>
                $<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>
diff --git a/opencl/source/CMakeLists.txt b/opencl/source/CMakeLists.txt
@@ -121,12 +121,12 @@ if(${GENERATE_EXECUTABLE})
                    $<TARGET_OBJECTS:${AUB_STREAM_PROJECT_NAME}_all_hw>
                    ${NEO_SOURCE_DIR}/shared/source/aub/aub_stream_interface.cpp
     )
+    target_link_libraries(${NEO_DYNAMIC_LIB_NAME} PRIVATE ${AUB_STREAM_PROJECT_NAME})
   else()
     target_sources(${NEO_DYNAMIC_LIB_NAME}
                    PRIVATE
-                   ${NEO_SOURCE_DIR}/shared/source/aub/aub_stream_interface_stub.cpp
+                   $<TARGET_OBJECTS:aub_stream_stubs>
     )
-
   endif()
 
   if(UNIX)
diff --git a/opencl/test/unit_test/CMakeLists.txt b/opencl/test/unit_test/CMakeLists.txt
@@ -55,6 +55,7 @@ set(NEO_IGDRCL_TESTS__TARGET_OBJECTS
     $<TARGET_OBJECTS:neo_libult_cs>
     $<TARGET_OBJECTS:neo_libult>
     $<TARGET_OBJECTS:igdrcl_libult_env>
+    $<TARGET_OBJECTS:mock_aubstream>
     $<TARGET_OBJECTS:mock_gmm>
     $<TARGET_OBJECTS:${SHARINGS_ENABLE_LIB_NAME}>
     $<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
diff --git a/opencl/test/unit_test/aub_tests/CMakeLists.txt b/opencl/test/unit_test/aub_tests/CMakeLists.txt
@@ -53,6 +53,8 @@ if(NOT NEO_SKIP_AUB_TESTS AND DEFINED AUB_STREAM_PROJECT_NAME)
   target_link_libraries(igdrcl_aub_tests ${NEO_MOCKABLE_LIB_NAME} ${NEO_SHARED_MOCKABLE_LIB_NAME})
   target_link_libraries(igdrcl_aub_tests igdrcl_mocks)
   target_link_libraries(igdrcl_aub_tests gmock-gtest ${NEO_EXTRA_LIBS})
+  target_link_libraries(igdrcl_aub_tests ${AUB_STREAM_PROJECT_NAME})
+
   if(UNIX)
     target_link_libraries(igdrcl_aub_tests ${GMM_LINK_NAME})
   else()
diff --git a/opencl/test/unit_test/linux/CMakeLists.txt b/opencl/test/unit_test/linux/CMakeLists.txt
@@ -14,6 +14,7 @@ add_executable(igdrcl_${target_name}
                $<TARGET_OBJECTS:neo_libult_cs>
                $<TARGET_OBJECTS:neo_shared_mocks>
                $<TARGET_OBJECTS:neo_unit_tests_config>
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                ${CMAKE_CURRENT_SOURCE_DIR}/drm_wrap.h
                ${CMAKE_CURRENT_SOURCE_DIR}/main_linux_dll.cpp
diff --git a/opencl/test/unit_test/mt_tests/CMakeLists.txt b/opencl/test/unit_test/mt_tests/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2018-2023 Intel Corporation
+# Copyright (C) 2018-2024 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -19,6 +19,7 @@ add_executable(igdrcl_mt_tests EXCLUDE_FROM_ALL
                $<TARGET_OBJECTS:neo_shared_mocks>
                $<TARGET_OBJECTS:neo_mt_tests_config>
                $<TARGET_OBJECTS:igdrcl_libult_env>
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                $<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>
 )
diff --git a/opencl/test/unit_test/windows/CMakeLists.txt b/opencl/test/unit_test/windows/CMakeLists.txt
@@ -13,6 +13,7 @@ if(WIN32)
       $<TARGET_OBJECTS:neo_unit_tests_config>
       $<TARGET_OBJECTS:igdrcl_libult>
       $<TARGET_OBJECTS:igdrcl_libult_env>
+      $<TARGET_OBJECTS:mock_aubstream>
       $<TARGET_OBJECTS:mock_gmm>
   )
 
diff --git a/shared/source/CMakeLists.txt b/shared/source/CMakeLists.txt
@@ -73,10 +73,6 @@ function(generate_shared_lib LIB_NAME MOCKABLE)
     endif()
   endif()
 
-  if(DEFINED AUB_STREAM_PROJECT_NAME)
-    target_link_libraries(${LIB_NAME} ${AUB_STREAM_PROJECT_NAME})
-  endif()
-
 endfunction()
 
 set(NEO_CORE_COMPILE_DEFS "")
diff --git a/shared/source/aub_mem_dump/CMakeLists.txt b/shared/source/aub_mem_dump/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020-2023 Intel Corporation
+# Copyright (C) 2020-2024 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -17,19 +17,6 @@ set(NEO_CORE_AUB_MEM_DUMP
     ${CMAKE_CURRENT_SOURCE_DIR}/page_table_entry_bits.h
 )
 
-if(NOT DEFINED AUB_STREAM_PROJECT_NAME)
-  list(APPEND NEO_CORE_AUB_MEM_DUMP
-       ${CMAKE_CURRENT_SOURCE_DIR}/aub_stream_stubs.cpp
-  )
-else()
-  add_library(aub_stream_stubs STATIC
-              ${CMAKE_CURRENT_SOURCE_DIR}/aub_stream_stubs.cpp
-  )
-  target_include_directories(aub_stream_stubs PRIVATE
-                             ${AUB_STREAM_HEADERS_DIR}
-  )
-endif()
-
 if(SUPPORT_XEHP_AND_LATER)
   list(APPEND NEO_CORE_AUB_MEM_DUMP
        ${CMAKE_CURRENT_SOURCE_DIR}/aub_mem_dump_xehp_and_later.inl
diff --git a/shared/source/aub_stream_stubs/CMakeLists.txt b/shared/source/aub_stream_stubs/CMakeLists.txt
@@ -0,0 +1,15 @@
+#
+# Copyright (C) 2024 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(NOT DEFINED AUB_STREAM_PROJECT_NAME)
+  add_library(aub_stream_stubs OBJECT EXCLUDE_FROM_ALL
+              ${CMAKE_CURRENT_SOURCE_DIR}/aub_stream_interface_stub.cpp
+              ${CMAKE_CURRENT_SOURCE_DIR}/aub_stream_stubs.cpp
+  )
+  target_include_directories(aub_stream_stubs PRIVATE
+                             ${AUB_STREAM_HEADERS_DIR}
+  )
+endif()
diff --git a/shared/source/aub_stream_stubs/aub_stream_interface_stub.cpp b/shared/source/aub_stream_stubs/aub_stream_interface_stub.cpp
@@ -1,11 +1,11 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
-#include "shared/source/aub/aub_center.h"
+#include "aubstream/aub_manager.h"
 
 namespace NEO {
 aub_stream::AubManager *createAubManager(const aub_stream::AubManagerOptions &options) {
diff --git a/shared/source/aub_stream_stubs/aub_stream_stubs.cpp b/shared/source/aub_stream_stubs/aub_stream_stubs.cpp
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2018-2024 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "aubstream/aubstream.h"
+
+#include <limits>
+
+namespace aub_stream {
+
+extern "C" {
+void injectMMIOList(MMIOList mmioList){};
+void setTbxServerPort(uint16_t port){};
+void setTbxServerIp(std::string server){};
+void setTbxFrontdoorMode(bool frontdoor){};
+void setAubStreamCaller(uint32_t caller){};
+}
+
+} // namespace aub_stream
diff --git a/shared/test/common/mock_aubstream/CMakeLists.txt b/shared/test/common/mock_aubstream/CMakeLists.txt
@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2024 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+project(mock_aubstream)
+
+add_library(
+            mock_aubstream EXCLUDE_FROM_ALL OBJECT
+            ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+            ${CMAKE_CURRENT_SOURCE_DIR}/mock_aubstream.cpp
+)
+
+create_project_source_tree(mock_aubstream)
+set_target_properties(mock_aubstream PROPERTIES FOLDER "test mocks")
+target_include_directories(mock_aubstream PRIVATE ${AUB_STREAM_HEADERS_DIR})
diff --git a/shared/test/common/mock_aubstream/mock_aubstream.cpp b/shared/test/common/mock_aubstream/mock_aubstream.cpp
@@ -1,34 +1,39 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
 #include "aubstream/aubstream.h"
 
-#include <limits>
-
 namespace aub_stream_stubs {
 uint16_t tbxServerPort = 4321;
 std::string tbxServerIp = "127.0.0.1";
 bool tbxFrontdoorMode = false;
-uint32_t aubStreamCaller = std::numeric_limits<uint32_t>::max();
+aub_stream::MMIOList mmioListInjected;
 } // namespace aub_stream_stubs
 
 namespace aub_stream {
 
-extern "C" {
-void injectMMIOList(MMIOList mmioList){};
-void setTbxServerPort(uint16_t port) { aub_stream_stubs::tbxServerPort = port; };
+void injectMMIOList(MMIOList mmioList) {
+    aub_stream_stubs::mmioListInjected = mmioList;
+    aub_stream_stubs::mmioListInjected.shrink_to_fit();
+}
+void setTbxServerPort(uint16_t port) {
+    aub_stream_stubs::tbxServerPort = port;
+}
 void setTbxServerIp(std::string server) {
     // better to avoid reassigning global variables which assume memory allocations since
     // we could step into false-positive memory leak detection with embedded leak check helper
-    if (aub_stream_stubs::tbxServerIp != server)
+    if (aub_stream_stubs::tbxServerIp != server) {
         aub_stream_stubs::tbxServerIp = server;
-};
-void setTbxFrontdoorMode(bool frontdoor) { aub_stream_stubs::tbxFrontdoorMode = frontdoor; };
-void setAubStreamCaller(uint32_t caller) { aub_stream_stubs::aubStreamCaller = caller; };
+    }
+}
+void setTbxFrontdoorMode(bool frontdoor) {
+    aub_stream_stubs::tbxFrontdoorMode = frontdoor;
+}
+void setAubStreamCaller(uint32_t caller) {
 }
 
 } // namespace aub_stream
diff --git a/shared/test/common/mock_gmm/CMakeLists.txt b/shared/test/common/mock_gmm/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2020-2021 Intel Corporation
+# Copyright (C) 2020-2024 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -21,5 +21,3 @@ target_include_directories(${target_name} PRIVATE
 
 create_project_source_tree(${target_name})
 set_target_properties(${target_name} PROPERTIES FOLDER "test mocks")
-target_compile_definitions(${target_name} PUBLIC)
-
diff --git a/shared/test/unit_test/CMakeLists.txt b/shared/test/unit_test/CMakeLists.txt
@@ -23,6 +23,7 @@ add_executable(neo_shared_tests
                ${NEO_SHARED_TEST_DIRECTORY}/common/common_main.cpp
                ${NEO_SHARED_TEST_DIRECTORY}/common/helpers/virtual_file_system_listener.cpp
                ${NEO_SHARED_TEST_DIRECTORY}/common/tests_configuration.h
+               $<TARGET_OBJECTS:mock_aubstream>
                $<TARGET_OBJECTS:mock_gmm>
                $<TARGET_OBJECTS:neo_libult_common>
                $<TARGET_OBJECTS:neo_libult_cs>
diff --git a/shared/test/unit_test/aub/CMakeLists.txt b/shared/test/unit_test/aub/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2018-2022 Intel Corporation
+# Copyright (C) 2018-2024 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -10,8 +10,6 @@ target_sources(neo_shared_tests PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/aub_helper_tests.cpp
 )
 
-if(NOT DEFINED AUB_STREAM_PROJECT_NAME)
-  target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_stubs_tests.cpp)
-endif()
+target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_stubs_tests.cpp)
 
 add_subdirectories()
diff --git a/shared/test/unit_test/aub/aub_center_using_aubstream_stubs_tests.cpp b/shared/test/unit_test/aub/aub_center_using_aubstream_stubs_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2023 Intel Corporation
+ * Copyright (C) 2018-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,28 +30,31 @@ TEST(AubCenter, GivenUseAubStreamAndTbxServerIpDebugVariableSetWhenAubCenterIsCr
     debugManager.flags.TbxServer.set("10.10.10.10");
     VariableBackup<std::string> backup(&aub_stream_stubs::tbxServerIp);
 
+    ASSERT_STRNE("10.10.10.10", aub_stream_stubs::tbxServerIp.c_str());
+
     MockExecutionEnvironment executionEnvironment{};
     auto &rootDeviceEnvironment = *executionEnvironment.rootDeviceEnvironments[0];
 
-    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::CSR_TBX);
+    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::tbx);
 
     EXPECT_STREQ("10.10.10.10", aub_stream_stubs::tbxServerIp.c_str());
 }
 
-TEST(AubCenter, GivenUseAubStreamAndTbxServerPortDebugVariableSetWhenAubCenterIsCreatedThenServerIpIsModified) {
+TEST(AubCenter, GivenUseAubStreamAndTbxServerPortDebugVariableSetWhenAubCenterIsCreatedThenServerPortIsModified) {
     DebugManagerStateRestore restorer;
     debugManager.flags.UseAubStream.set(true);
     debugManager.flags.TbxPort.set(1234);
 
     VariableBackup<uint16_t> backup(&aub_stream_stubs::tbxServerPort);
 
+    aub_stream_stubs::tbxServerPort = 4321u;
     uint16_t port = 1234u;
-    EXPECT_NE(port, aub_stream_stubs::tbxServerPort);
+    ASSERT_NE(port, aub_stream_stubs::tbxServerPort);
 
     MockExecutionEnvironment executionEnvironment{};
     auto &rootDeviceEnvironment = *executionEnvironment.rootDeviceEnvironments[0];
 
-    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::CSR_TBX);
+    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::tbx);
     EXPECT_EQ(port, aub_stream_stubs::tbxServerPort);
 }
 
@@ -62,11 +65,12 @@ TEST(AubCenter, GivenUseAubStreamAndTbxFrontdoorModeDebugVariableSetWhenAubCente
 
     VariableBackup<bool> backup(&aub_stream_stubs::tbxFrontdoorMode);
 
+    aub_stream_stubs::tbxFrontdoorMode = false;
     EXPECT_FALSE(aub_stream_stubs::tbxFrontdoorMode);
 
     MockExecutionEnvironment executionEnvironment{};
     auto &rootDeviceEnvironment = *executionEnvironment.rootDeviceEnvironments[0];
 
-    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::CSR_TBX);
+    MockAubCenter aubCenter(rootDeviceEnvironment, false, "", CommandStreamReceiverType::tbx);
     EXPECT_TRUE(aub_stream_stubs::tbxFrontdoorMode);
 }

Original file line number	Diff line number	Diff line change
`@@ -231,10 +231,11 @@ if(BUILD_WITH_L0)`
`231`	`231`	`PRIVATE`
`232`	`232`	`${NEO_SHARED_DIRECTORY}/aub/aub_stream_interface.cpp`
`233`	`233`	`)`
	`234`	`+ target_link_libraries(${TARGET_NAME_L0} PRIVATE ${AUB_STREAM_PROJECT_NAME})`
`234`	`235`	`else()`
`235`	`236`	`target_sources(${TARGET_NAME_L0}`
`236`	`237`	`PRIVATE`
`237`		`- ${NEO_SHARED_DIRECTORY}/aub/aub_stream_interface_stub.cpp`
	`238`	`+ $<TARGET_OBJECTS:aub_stream_stubs>`
`238`	`239`	`)`
`239`	`240`
`240`	`241`	`endif()`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,7 @@ target_link_libraries(${TARGET_NAME}`
`72`	`72`	`)`
`73`	`73`
`74`	`74`	`target_sources(${TARGET_NAME} PRIVATE`
	`75`	`+ $<TARGET_OBJECTS:mock_aubstream>`
`75`	`76`	`$<TARGET_OBJECTS:mock_gmm>`
`76`	`77`	`$<TARGET_OBJECTS:${TARGET_NAME_L0}_fixtures>`
`77`	`78`	`$<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>`
Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,7 @@ target_link_libraries(${TARGET_NAME}`
`71`	`71`	`)`
`72`	`72`
`73`	`73`	`target_sources(${TARGET_NAME} PRIVATE`
	`74`	`+ $<TARGET_OBJECTS:mock_aubstream>`
`74`	`75`	`$<TARGET_OBJECTS:mock_gmm>`
`75`	`76`	`$<TARGET_OBJECTS:${TARGET_NAME_L0}_fixtures>`
`76`	`77`	`$<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>`
Original file line number	Diff line number	Diff line change
`@@ -121,12 +121,12 @@ if(${GENERATE_EXECUTABLE})`
`121`	`121`	`$<TARGET_OBJECTS:${AUB_STREAM_PROJECT_NAME}_all_hw>`
`122`	`122`	`${NEO_SOURCE_DIR}/shared/source/aub/aub_stream_interface.cpp`
`123`	`123`	`)`
	`124`	`+ target_link_libraries(${NEO_DYNAMIC_LIB_NAME} PRIVATE ${AUB_STREAM_PROJECT_NAME})`
`124`	`125`	`else()`
`125`	`126`	`target_sources(${NEO_DYNAMIC_LIB_NAME}`
`126`	`127`	`PRIVATE`
`127`		`- ${NEO_SOURCE_DIR}/shared/source/aub/aub_stream_interface_stub.cpp`
	`128`	`+ $<TARGET_OBJECTS:aub_stream_stubs>`
`128`	`129`	`)`
`129`		`-`
`130`	`130`	`endif()`
`131`	`131`
`132`	`132`	`if(UNIX)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`#`
`2`		`-# Copyright (C) 2018-2023 Intel Corporation`
	`2`	`+# Copyright (C) 2018-2024 Intel Corporation`
`3`	`3`	`#`
`4`	`4`	`# SPDX-License-Identifier: MIT`
`5`	`5`	`#`
`@@ -19,6 +19,7 @@ add_executable(igdrcl_mt_tests EXCLUDE_FROM_ALL`
`19`	`19`	`$<TARGET_OBJECTS:neo_shared_mocks>`
`20`	`20`	`$<TARGET_OBJECTS:neo_mt_tests_config>`
`21`	`21`	`$<TARGET_OBJECTS:igdrcl_libult_env>`
	`22`	`+ $<TARGET_OBJECTS:mock_aubstream>`
`22`	`23`	`$<TARGET_OBJECTS:mock_gmm>`
`23`	`24`	`$<TARGET_OBJECTS:${BUILTINS_SOURCES_LIB_NAME}>`
`24`	`25`	`)`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ if(WIN32)`
`13`	`13`	`$<TARGET_OBJECTS:neo_unit_tests_config>`
`14`	`14`	`$<TARGET_OBJECTS:igdrcl_libult>`
`15`	`15`	`$<TARGET_OBJECTS:igdrcl_libult_env>`
	`16`	`+ $<TARGET_OBJECTS:mock_aubstream>`
`16`	`17`	`$<TARGET_OBJECTS:mock_gmm>`
`17`	`18`	`)`
`18`	`19`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2022 Intel Corporation`
	`2`	`+ * Copyright (C) 2022-2024 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`6`	`6`	`*/`
`7`	`7`
`8`		`-#include "shared/source/aub/aub_center.h"`
	`8`	`+#include "aubstream/aub_manager.h"`
`9`	`9`
`10`	`10`	`namespace NEO {`
`11`	`11`	`aub_stream::AubManager *createAubManager(const aub_stream::AubManagerOptions &options) {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`#`
`2`		`-# Copyright (C) 2020-2021 Intel Corporation`
	`2`	`+# Copyright (C) 2020-2024 Intel Corporation`
`3`	`3`	`#`
`4`	`4`	`# SPDX-License-Identifier: MIT`
`5`	`5`	`#`
`@@ -21,5 +21,3 @@ target_include_directories(${target_name} PRIVATE`
`21`	`21`
`22`	`22`	`create_project_source_tree(${target_name})`
`23`	`23`	`set_target_properties(${target_name} PROPERTIES FOLDER "test mocks")`
`24`		`-target_compile_definitions(${target_name} PUBLIC)`
`25`		`-`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`#`
`2`		`-# Copyright (C) 2018-2022 Intel Corporation`
	`2`	`+# Copyright (C) 2018-2024 Intel Corporation`
`3`	`3`	`#`
`4`	`4`	`# SPDX-License-Identifier: MIT`
`5`	`5`	`#`
`@@ -10,8 +10,6 @@ target_sources(neo_shared_tests PRIVATE`
`10`	`10`	`${CMAKE_CURRENT_SOURCE_DIR}/aub_helper_tests.cpp`
`11`	`11`	`)`
`12`	`12`
`13`		`-if(NOT DEFINED AUB_STREAM_PROJECT_NAME)`
`14`		`- target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_stubs_tests.cpp)`
`15`		`-endif()`
	`13`	`+target_sources(neo_shared_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/aub_center_using_aubstream_stubs_tests.cpp)`
`16`	`14`
`17`	`15`	`add_subdirectories()`