test: remove gmock from metrics ult

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

level_zero/core/test/common/ult_specific_config_l0.cpp

@@ -11,8 +11,6 @@
 
 #include "level_zero/core/source/cmdlist/cmdlist.h"
 
-#include "gmock/gmock.h"
-
 using namespace NEO;
 void cleanTestHelpers() {}
 
@@ -24,24 +22,6 @@ void applyWorkarounds() {
     if (sysmanUltsEnableEnv != nullptr) {
         sysmanUltsEnable = (strcmp(sysmanUltsEnableEnv, "1") == 0);
     }
-    {
-        class BaseClass {
-          public:
-            int method(int param) { return 1; }
-        };
-        class MockClass : public BaseClass {
-          public:
-            MOCK_METHOD1(method, int(int param));
-        };
-        ::testing::NiceMock<MockClass> mockObj;
-        EXPECT_CALL(mockObj, method(::testing::_))
-            .Times(1);
-        mockObj.method(2);
-    }
-}
-
-void initGTest(int &argc, char **argv) {
-    testing::InitGoogleMock(&argc, argv);
 }
 
 bool isPlatformSupported(const HardwareInfo &hwInfoForTests) {

level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp

@@ -15,12 +15,8 @@
 #include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace NEO {
 namespace SysCalls {
 extern int fstatFuncRetVal;
@@ -72,8 +68,7 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenActivateConfigurationI
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
+    mockMetricsLibrary->g_mockApi->configurationActivationCounter = 1;
-        .WillOnce(Return(StatusCode::Success));
     EXPECT_TRUE(mockMetricsLibrary->activateConfiguration(dummyConfigurationHandle));
 }
 
@@ -83,8 +78,8 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenActivateConfigurationI
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
+    mockMetricsLibrary->g_mockApi->configurationActivationCounter = 1;
-        .WillOnce(Return(StatusCode::Failed));
+    mockMetricsLibrary->g_mockApi->configurationActivateResult = StatusCode::Failed;
     EXPECT_FALSE(mockMetricsLibrary->activateConfiguration(dummyConfigurationHandle));
 }
 
@@ -94,8 +89,6 @@ TEST_F(MetricQueryPoolLinuxTest, givenInCorrectConfigurationWhenActivateConfigur
     dummyConfigurationHandle.data = nullptr;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
-    ON_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
-        .WillByDefault(Return(StatusCode::Success));
     EXPECT_FALSE(mockMetricsLibrary->activateConfiguration(dummyConfigurationHandle));
 }
 
@@ -105,8 +98,7 @@ TEST_F(MetricQueryPoolLinuxTest, givenMetricLibraryIsInIncorrectInitializedState
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_ERROR_UNKNOWN;
 
-    ON_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
+    mockMetricsLibrary->g_mockApi->configurationActivationCounter = 1;
-        .WillByDefault(Return(StatusCode::Success));
     EXPECT_FALSE(mockMetricsLibrary->activateConfiguration(dummyConfigurationHandle));
 }
 
@@ -116,8 +108,7 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenDeActivateConfiguratio
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
+    mockMetricsLibrary->g_mockApi->configurationDeactivationCounter = 1;
-        .WillOnce(Return(StatusCode::Success));
     EXPECT_TRUE(mockMetricsLibrary->deactivateConfiguration(dummyConfigurationHandle));
 }
 
@@ -127,8 +118,8 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenDeActivateConfiguratio
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
+    mockMetricsLibrary->g_mockApi->configurationDeactivationCounter = 1;
-        .WillOnce(Return(StatusCode::Failed));
+    mockMetricsLibrary->g_mockApi->configurationDeactivateResult = StatusCode::Failed;
     EXPECT_FALSE(mockMetricsLibrary->deactivateConfiguration(dummyConfigurationHandle));
 }
 
@@ -137,9 +128,7 @@ TEST_F(MetricQueryPoolLinuxTest, givenInCorrectConfigurationWhenDeActivateConfig
     ConfigurationHandle_1_0 dummyConfigurationHandle;
     dummyConfigurationHandle.data = nullptr;
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
-
+    mockMetricsLibrary->g_mockApi->configurationDeactivationCounter = 1;
-    ON_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
-        .WillByDefault(Return(StatusCode::Success));
     EXPECT_FALSE(mockMetricsLibrary->deactivateConfiguration(dummyConfigurationHandle));
 }
 
@@ -149,8 +138,6 @@ TEST_F(MetricQueryPoolLinuxTest, givenMetricLibraryIsInIncorrectInitializedState
     dummyConfigurationHandle.data = &dummyConfigurationHandle;
     mockMetricsLibrary->initializationState = ZE_RESULT_ERROR_UNKNOWN;
 
-    ON_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
-        .WillByDefault(Return(StatusCode::Success));
     EXPECT_FALSE(mockMetricsLibrary->deactivateConfiguration(dummyConfigurationHandle));
 }
 
@@ -175,9 +162,6 @@ TEST_F(MetricQueryPoolLinuxTest, givenCorrectArgumentsWhenCacheConfigurationIsCa
 
     metricsSet.GetParamsResult = &metricsSetParams;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
-        .WillOnce(Return(StatusCode::Success));
-
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
     EXPECT_EQ(metricGroupCount, 1u);
@@ -259,13 +243,9 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdap
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = adapterParams.SystemId.MajorMinor.Major;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = adapterParams.SystemId.MajorMinor.Minor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
@@ -295,13 +275,9 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorPrimaryNodeDrmAdapterWh
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = drmMajor;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = drmMinor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(drmMajor), ::testing::SetArgReferee<1>(drmMinor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
@@ -331,13 +307,9 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxMinorRenderNodeDrmAdapterWhe
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = drmMajor;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = drmMinor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(drmMajor), ::testing::SetArgReferee<1>(drmMinor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
@@ -359,13 +331,9 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterTypeWhenGe
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = adapterParams.SystemId.MajorMinor.Major;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = adapterParams.SystemId.MajorMinor.Minor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
@@ -392,13 +360,9 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMajorWhenG
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = incorrectMajor;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = adapterParams.SystemId.MajorMinor.Minor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(incorrectMajor), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
@@ -423,13 +387,9 @@ TEST_F(MetricEnumerationTestLinux, givenIcorrectMetricDiscoveryAdapterMinorWhenG
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = adapterParams.SystemId.MajorMinor.Major;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = incorrectMinor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(incorrectMinor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_NE(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
@@ -453,13 +413,9 @@ TEST_F(MetricEnumerationTestLinux, givenIncorrectOpenMetricDeviceOnAdapterWhenGe
 
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = adapterParams.SystemId.MajorMinor.Major;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = adapterParams.SystemId.MajorMinor.Minor;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.MajorMinor.Major), ::testing::SetArgReferee<1>(adapterParams.SystemId.MajorMinor.Minor), Return(true)));
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     adapter.openMetricsDeviceResult = TCompletionCode::CC_ERROR_GENERAL;
 
@@ -474,7 +430,8 @@ TEST_F(MetricEnumerationTestLinux, givenCorrectDrmFileForFstatWhenGetMetricsAdap
     VariableBackup<int> fstatBackup(&NEO::SysCalls::fstatFuncRetVal);
     NEO::SysCalls::fstatFuncRetVal = 0;
 
-    EXPECT_EQ(mockMetricEnumeration->baseGetAdapterId(drmMajor, drmMinor), true);
+    mockMetricEnumeration->getAdapterIdCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->getAdapterId(drmMajor, drmMinor), true);
 }
 
 TEST_F(MetricEnumerationTestLinux, givenIncorrectDrmFileForFstatWhenGetMetricsAdapterThenReturnFail) {
@@ -485,7 +442,8 @@ TEST_F(MetricEnumerationTestLinux, givenIncorrectDrmFileForFstatWhenGetMetricsAd
     VariableBackup<int> fstatBackup(&NEO::SysCalls::fstatFuncRetVal);
     NEO::SysCalls::fstatFuncRetVal = -1;
 
-    EXPECT_EQ(mockMetricEnumeration->baseGetAdapterId(drmMajor, drmMinor), false);
+    mockMetricEnumeration->getAdapterIdCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->getAdapterId(drmMajor, drmMinor), false);
 }
 
 } // namespace ult

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp

@@ -17,9 +17,6 @@
 
 using namespace MetricsLibraryApi;
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -74,22 +71,14 @@ void MetricContextFixture::tearDown() {
 
 void MetricContextFixture::openMetricsAdapter() {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
-    adapter.openMetricsDeviceOutDevice = &metricsDevice;
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
 
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
+    adapter.openMetricsDeviceOutDevice = &metricsDevice;
-        .Times(1)
-        .WillOnce(Return(&adapter));
 }
 
 void MetricContextFixture::openMetricsAdapterGroup() {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
 }
@@ -177,48 +166,34 @@ void MetricMultiDeviceFixture::tearDown() {
 
 void MetricMultiDeviceFixture::openMetricsAdapter() {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
+
     adapter.openMetricsSubDeviceOutDevice = &metricsDevice;
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
-
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce(Return(&adapter));
 }
 
 void MetricMultiDeviceFixture::openMetricsAdapterSubDevice(uint32_t subDeviceIndex) {
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
-    adapter.openMetricsDeviceOutDevice = &metricsDevice;
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], getMetricsAdapter())
+    mockMetricEnumerationSubDevices[subDeviceIndex]->getMetricsAdapterResult = &adapter;
-        .Times(1)
+
-        .WillOnce(Return(&adapter));
+    adapter.openMetricsDeviceOutDevice = &metricsDevice;
 }
 
 void MetricMultiDeviceFixture::openMetricsAdapterDeviceAndSubDeviceNoCountVerify(uint32_t subDeviceIndex) {
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
-    adapter.openMetricsSubDeviceOutDevice = &metricsDevice;
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
+    mockMetricEnumerationSubDevices[subDeviceIndex]->getMetricsAdapterResult = &adapter;
 
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .WillRepeatedly(Return(&adapter));
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
-
+    adapter.openMetricsSubDeviceOutDevice = &metricsDevice;
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[subDeviceIndex], getMetricsAdapter())
-        .WillRepeatedly(Return(&adapter));
 }
 
 void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(0);
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
 }
@@ -303,67 +278,67 @@ void Mock<MetricsLibrary>::setMockedApi(MockMetricsLibraryApi *mockedApi) {
 }
 
 StatusCode MockMetricsLibraryApi::contextCreate(ClientType_1_0 clientType, ContextCreateData_1_0 *createData, ContextHandle_1_0 *handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockContextCreate(clientType, createData, handle);
+    return Mock<MetricsLibrary>::g_mockApi->contextCreateImpl(clientType, createData, handle);
 }
 
 StatusCode MockMetricsLibraryApi::contextDelete(const ContextHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockContextDelete(handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::getParameter(const ParameterType parameter, ValueType *type, TypedValue_1_0 *value) {
-    return Mock<MetricsLibrary>::g_mockApi->MockGetParameter(parameter, type, value);
+    return Mock<MetricsLibrary>::g_mockApi->getParameterImpl(parameter, type, value);
 }
 
 StatusCode MockMetricsLibraryApi::commandBufferGet(const CommandBufferData_1_0 *data) {
-    return Mock<MetricsLibrary>::g_mockApi->MockCommandBufferGet(data);
+    return Mock<MetricsLibrary>::g_mockApi->commandBufferGetImpl(data);
 }
 
 StatusCode MockMetricsLibraryApi::commandBufferGetSize(const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size) {
-    return Mock<MetricsLibrary>::g_mockApi->MockCommandBufferGetSize(data, size);
+    return Mock<MetricsLibrary>::g_mockApi->commandBufferGetSizeImpl(data, size);
 }
 
 StatusCode MockMetricsLibraryApi::queryCreate(const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockQueryCreate(createData, handle);
+    return Mock<MetricsLibrary>::g_mockApi->queryCreateImpl(createData, handle);
 }
 
 StatusCode MockMetricsLibraryApi::queryDelete(const QueryHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockQueryDelete(handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::overrideCreate(const OverrideCreateData_1_0 *createData, OverrideHandle_1_0 *handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockOverrideCreate(createData, handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::overrideDelete(const OverrideHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockOverrideDelete(handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::markerCreate(const MarkerCreateData_1_0 *createData, MarkerHandle_1_0 *handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockMarkerCreate(createData, handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::markerDelete(const MarkerHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockMarkerDelete(handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::configurationCreate(const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockConfigurationCreate(createData, handle);
+    return Mock<MetricsLibrary>::g_mockApi->configurationCreateImpl(createData, handle);
 }
 
 StatusCode MockMetricsLibraryApi::configurationActivate(const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData) {
-    return Mock<MetricsLibrary>::g_mockApi->MockConfigurationActivate(handle, activateData);
+    return Mock<MetricsLibrary>::g_mockApi->configurationActivateImpl(handle, activateData);
 }
 
 StatusCode MockMetricsLibraryApi::configurationDeactivate(const ConfigurationHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockConfigurationDeactivate(handle);
+    return Mock<MetricsLibrary>::g_mockApi->configurationDeactivateImpl(handle);
 }
 
 StatusCode MockMetricsLibraryApi::configurationDelete(const ConfigurationHandle_1_0 handle) {
-    return Mock<MetricsLibrary>::g_mockApi->MockConfigurationDelete(handle);
+    return StatusCode::Success;
 }
 
 StatusCode MockMetricsLibraryApi::getData(GetReportData_1_0 *data) {
-    return Mock<MetricsLibrary>::g_mockApi->MockGetData(data);
+    return Mock<MetricsLibrary>::g_mockApi->getDataImpl(data);
 }
 
 Mock<MetricQuery>::Mock() {}

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h

@@ -75,23 +75,92 @@ struct MockMetricsLibraryApi {
     static StatusCode ML_STDCALL configurationDelete(const ConfigurationHandle_1_0 handle);
     static StatusCode ML_STDCALL getData(GetReportData_1_0 *data);
 
-    // Mocked api functions.
+    StatusCode contextCreateImpl(ClientType_1_0 clientType, ContextCreateData_1_0 *createData, ContextHandle_1_0 *handle) {
-    MOCK_METHOD(StatusCode, MockContextCreate, (ClientType_1_0 clientType, ContextCreateData_1_0 *createData, ContextHandle_1_0 *handle));
+        *handle = contextCreateOutHandle;
-    MOCK_METHOD(StatusCode, MockContextDelete, (const ContextHandle_1_0 handle));
+
-    MOCK_METHOD(StatusCode, MockGetParameter, (const ParameterType parameter, ValueType *type, TypedValue_1_0 *value));
+        return contextCreateResult;
-    MOCK_METHOD(StatusCode, MockCommandBufferGet, (const CommandBufferData_1_0 *data));
+    }
-    MOCK_METHOD(StatusCode, MockCommandBufferGetSize, (const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size));
+
-    MOCK_METHOD(StatusCode, MockQueryCreate, (const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle));
+    StatusCode queryCreateImpl(const QueryCreateData_1_0 *createData, QueryHandle_1_0 *handle) {
-    MOCK_METHOD(StatusCode, MockQueryDelete, (const QueryHandle_1_0 handle));
+        *handle = queryCreateOutHandle;
-    MOCK_METHOD(StatusCode, MockOverrideCreate, (const OverrideCreateData_1_0 *createData, OverrideHandle_1_0 *handle));
+        if (!queryCreateResults.empty()) {
-    MOCK_METHOD(StatusCode, MockOverrideDelete, (const OverrideHandle_1_0 handle));
+            auto retVal = queryCreateResults.back();
-    MOCK_METHOD(StatusCode, MockMarkerCreate, (const MarkerCreateData_1_0 *createData, MarkerHandle_1_0 *handle));
+            queryCreateResults.pop_back();
-    MOCK_METHOD(StatusCode, MockMarkerDelete, (const MarkerHandle_1_0 handle));
+            return retVal;
-    MOCK_METHOD(StatusCode, MockConfigurationCreate, (const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle));
+        }
-    MOCK_METHOD(StatusCode, MockConfigurationActivate, (const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData));
+        return queryCreateResult;
-    MOCK_METHOD(StatusCode, MockConfigurationDeactivate, (const ConfigurationHandle_1_0 handle));
+    }
-    MOCK_METHOD(StatusCode, MockConfigurationDelete, (const ConfigurationHandle_1_0 handle));
+
-    MOCK_METHOD(StatusCode, MockGetData, (GetReportData_1_0 * data));
+    StatusCode configurationCreateImpl(const ConfigurationCreateData_1_0 *createData, ConfigurationHandle_1_0 *handle) {
+        *handle = configurationCreateOutHandle;
+
+        return configurationCreateResult;
+    }
+
+    StatusCode configurationActivateImpl(const ConfigurationHandle_1_0 handle, const ConfigurationActivateData_1_0 *activateData) {
+        EXPECT_LT(0u, configurationActivationCounter);
+        configurationActivationCounter--;
+
+        return configurationActivateResult;
+    }
+
+    StatusCode configurationDeactivateImpl(const ConfigurationHandle_1_0 handle) {
+        EXPECT_LT(0u, configurationDeactivationCounter);
+        configurationDeactivationCounter--;
+
+        return configurationDeactivateResult;
+    }
+    StatusCode getParameterImpl(const ParameterType parameter, ValueType *type, TypedValue_1_0 *value) {
+        *value = getParameterOutValue;
+        return getParameterResult;
+    }
+    StatusCode commandBufferGetImpl(const CommandBufferData_1_0 *data) {
+        return commandBufferGetResult;
+    }
+
+    StatusCode commandBufferGetSizeImpl(const CommandBufferData_1_0 *data, CommandBufferSize_1_0 *size) {
+        *size = commandBufferGetSizeOutSize;
+        return commandBufferGetSizeResult;
+    }
+
+    StatusCode getDataImpl(GetReportData_1_0 *data) {
+        if (getDataExpectedData) {
+            EXPECT_EQ(data->Query.Slot, getDataExpectedData->Query.Slot);
+            EXPECT_EQ(data->Query.SlotsCount, getDataExpectedData->Query.SlotsCount);
+            EXPECT_EQ(data->Query.Handle.data, getDataExpectedData->Query.Handle.data);
+            EXPECT_EQ(data->Query.Data, getDataExpectedData->Query.Data);
+            EXPECT_EQ(data->Query.DataSize, getDataExpectedData->Query.DataSize);
+            EXPECT_EQ(data->Type, getDataExpectedData->Type);
+        }
+
+        if (!getDataResults.empty()) {
+            auto retVal = getDataResults.back();
+            getDataResults.pop_back();
+            return retVal;
+        }
+        return getDataResult;
+    }
+
+    ContextHandle_1_0 contextCreateOutHandle{};
+    QueryHandle_1_0 queryCreateOutHandle{};
+    ConfigurationHandle_1_0 configurationCreateOutHandle{};
+    TypedValue_1_0 getParameterOutValue{};
+    CommandBufferSize_1_0 commandBufferGetSizeOutSize{};
+    GetReportData_1_0 *getDataExpectedData = nullptr;
+    std::vector<StatusCode> queryCreateResults;
+    std::vector<StatusCode> getDataResults;
+    StatusCode contextCreateResult = StatusCode::Success;
+    StatusCode queryCreateResult = StatusCode::Success;
+    StatusCode configurationCreateResult = StatusCode::Success;
+    StatusCode configurationActivateResult = StatusCode::Success;
+    StatusCode configurationDeactivateResult = StatusCode::Success;
+    StatusCode getParameterResult = StatusCode::Success;
+    StatusCode commandBufferGetResult = StatusCode::Success;
+    StatusCode commandBufferGetSizeResult = StatusCode::Success;
+    StatusCode getDataResult = StatusCode::Success;
+
+    uint32_t configurationActivationCounter = 0u;
+    uint32_t configurationDeactivationCounter = 0u;
 };
 
 template <>
@@ -107,10 +176,13 @@ struct Mock<MetricsLibrary> : public MetricsLibrary {
     // Api mock enable/disable.
     void setMockedApi(MockMetricsLibraryApi *mockedApi);
 
-    // Mocked metrics library functions.
+    ADDMETHOD_NOBASE(load, bool, true, ());
-    MOCK_METHOD(bool, load, (), (override));
+    ADDMETHOD_NOBASE(getContextData, bool, true, (::L0::Device &, ContextCreateData_1_0 &));
-    MOCK_METHOD(bool, getContextData, (::L0::Device &, ContextCreateData_1_0 &), (override));
+
-    MOCK_METHOD(bool, getMetricQueryReportSize, (size_t & rawDataSize), (override));
+    bool getMetricQueryReportSize(size_t &rawDataSize) override {
+        rawDataSize = getMetricQueryReportSizeOutSize;
+        return getMetricQueryReportSizeResult;
+    }
 
     // Not mocked metrics library functions.
     bool metricsLibraryGetContextData(::L0::Device &device, ContextCreateData_1_0 &contextData) { return MetricsLibrary::getContextData(device, contextData); }
@@ -122,6 +194,9 @@ struct Mock<MetricsLibrary> : public MetricsLibrary {
     // We cannot use a static instance here since the gtest validates memory usage,
     // and mocked functions will stay in memory longer than the test.
     static MockMetricsLibraryApi *g_mockApi; // NOLINT(readability-identifier-naming)
+
+    size_t getMetricQueryReportSizeOutSize{};
+    bool getMetricQueryReportSizeResult = true;
 };
 
 template <>
@@ -129,8 +204,8 @@ struct Mock<MetricQueryPool> : public MetricQueryPool {
     Mock();
     ~Mock() override;
 
-    MOCK_METHOD(ze_result_t, metricQueryCreate, (uint32_t, zet_metric_query_handle_t *), (override));
+    ADDMETHOD_NOBASE(metricQueryCreate, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t, zet_metric_query_handle_t *));
-    MOCK_METHOD(ze_result_t, destroy, (), (override));
+    ADDMETHOD_NOBASE(destroy, ze_result_t, ZE_RESULT_SUCCESS, ());
 };
 
 template <>
@@ -138,9 +213,9 @@ struct Mock<MetricQuery> : public MetricQuery {
     Mock();
     ~Mock() override;
 
-    MOCK_METHOD(ze_result_t, getData, (size_t *, uint8_t *), (override));
+    ADDMETHOD_NOBASE(getData, ze_result_t, ZE_RESULT_SUCCESS, (size_t *, uint8_t *));
-    MOCK_METHOD(ze_result_t, reset, (), (override));
+    ADDMETHOD_NOBASE(reset, ze_result_t, ZE_RESULT_SUCCESS, ());
-    MOCK_METHOD(ze_result_t, destroy, (), (override));
+    ADDMETHOD_NOBASE(destroy, ze_result_t, ZE_RESULT_SUCCESS, ());
 };
 
 class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.cpp

@@ -15,9 +15,6 @@ namespace ult {
 Mock<MetricEnumeration>::Mock(::L0::OaMetricSourceImp &metricSource) : MetricEnumeration(metricSource) {
 }
 
-Mock<MetricEnumeration>::~Mock() {
-}
-
 MockMetricsDiscoveryApi *Mock<MetricEnumeration>::globalMockApi = nullptr;
 
 TCompletionCode MockMetricsDiscoveryApi::openAdapterGroup(IAdapterGroupLatest **group) {

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h

@@ -13,8 +13,6 @@
 #include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
 #include "level_zero/tools/source/metrics/metric_oa_query_imp.h"
 
-#include "gmock/gmock.h"
-
 namespace L0 {
 namespace ult {
 
@@ -217,10 +215,19 @@ class Mock<IMetricSet_1_5> : public IMetricSet_1_5 {
     ADDMETHOD_NOBASE(Activate, TCompletionCode, TCompletionCode::CC_OK, ());
     ADDMETHOD_NOBASE(Deactivate, TCompletionCode, TCompletionCode::CC_OK, ());
     ADDMETHOD_NOBASE(SetApiFiltering, TCompletionCode, TCompletionCode::CC_OK, (uint32_t apiMask));
-    MOCK_METHOD(TCompletionCode, CalculateMetrics, (const unsigned char *rawData, uint32_t rawDataSize, TTypedValue_1_0 *out, uint32_t outSize, uint32_t *outReportCount, bool enableContextFiltering), (override));
+    ADDMETHOD_NOBASE(CalculateMetrics, TCompletionCode, TCompletionCode::CC_OK, (const unsigned char *rawData, uint32_t rawDataSize, TTypedValue_1_0 *out, uint32_t outSize, uint32_t *outReportCount, bool enableContextFiltering));
     ADDMETHOD_NOBASE(CalculateIoMeasurementInformation, TCompletionCode, TCompletionCode::CC_OK, (TTypedValue_1_0 * out, uint32_t outSize));
-    MOCK_METHOD(IMetricSet_1_5 *, GetComplementaryMetricSet, (uint32_t index), (override));
+    ADDMETHOD_NOBASE(GetComplementaryMetricSet, IMetricSet_1_5 *, nullptr, (uint32_t index));
-    MOCK_METHOD(TCompletionCode, CalculateMetrics, (const unsigned char *rawData, uint32_t rawDataSize, TTypedValue_1_0 *out, uint32_t outSize, uint32_t *outReportCount, TTypedValue_1_0 *outMaxValues, uint32_t outMaxValuesSize), (override));
+
+    TCompletionCode CalculateMetrics(const unsigned char *rawData, uint32_t rawDataSize, TTypedValue_1_0 *out, uint32_t outSize, uint32_t *outReportCount, TTypedValue_1_0 *outMaxValues, uint32_t outMaxValuesSize) override {
+        if (calculateMetricsOutReportCount) {
+            *outReportCount = *calculateMetricsOutReportCount;
+        }
+        return calculateMetricsResult;
+    }
+
+    uint32_t *calculateMetricsOutReportCount = nullptr;
+    TCompletionCode calculateMetricsResult = TCompletionCode::CC_OK;
 };
 
 template <>
@@ -242,7 +249,9 @@ class Mock<IInformation_1_0> : public IInformation_1_0 {
 template <>
 struct Mock<MetricEnumeration> : public MetricEnumeration {
     Mock(::L0::OaMetricSourceImp &metricSource);
-    ~Mock() override;
+    ~Mock() override = default;
+
+    using BaseClass = MetricEnumeration;
 
     using MetricEnumeration::cleanupMetricsDiscovery;
     using MetricEnumeration::hMetricsDiscovery;
@@ -254,15 +263,20 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
     void setMockedApi(MockMetricsDiscoveryApi *mockedApi);
 
     // Mock metric enumeration functions.
-    MOCK_METHOD(bool, isInitialized, (), (override));
+    ADDMETHOD(isInitialized, bool, false, true, (), ());
-    MOCK_METHOD(ze_result_t, loadMetricsDiscovery, (), (override));
+    ADDMETHOD(loadMetricsDiscovery, ze_result_t, false, ZE_RESULT_SUCCESS, (), ());
-    MOCK_METHOD(MetricsDiscovery::IAdapter_1_9 *, getMetricsAdapter, (), (override));
+    ADDMETHOD_NOBASE(getMetricsAdapter, MetricsDiscovery::IAdapter_1_9 *, nullptr, ());
-    MOCK_METHOD(bool, getAdapterId, (uint32_t & drmMajor, uint32_t &drmMinor), (override));
+
+    bool getAdapterId(uint32_t &drmMajor, uint32_t &drmMinor) override {
+        if (getAdapterIdCallBase) {
+            return MetricEnumeration::getAdapterId(drmMajor, drmMinor);
+        }
+        drmMajor = getAdapterIdOutMajor;
+        drmMinor = getAdapterIdOutMinor;
+        return getAdapterIdResult;
+    }
 
     // Not mocked metrics enumeration functions.
-    bool baseIsInitialized() { return MetricEnumeration::isInitialized(); }
-    IAdapter_1_9 *baseGetMetricsAdapter() { return MetricEnumeration::getMetricsAdapter(); }
-    bool baseGetAdapterId(uint32_t &adapterMajor, uint32_t &adapterMinor) { return MetricEnumeration::getAdapterId(adapterMajor, adapterMinor); }
     ze_result_t baseLoadMetricsDiscovery() { return MetricEnumeration::loadMetricsDiscovery(); }
 
     // Mock metrics discovery api.
@@ -270,25 +284,36 @@ struct Mock<MetricEnumeration> : public MetricEnumeration {
 
     // Original metric enumeration obtained from metric context.
     ::L0::MetricEnumeration *metricEnumeration = nullptr;
+
+    uint32_t getAdapterIdOutMajor = 0u;
+    uint32_t getAdapterIdOutMinor = 0u;
+    bool getAdapterIdResult = true;
+    bool getAdapterIdCallBase = false;
 };
 
 template <>
 struct Mock<MetricGroup> : public OaMetricGroupImp {
-    Mock() {}
+    ~Mock() override = default;
+
+    ADDMETHOD_NOBASE(metricGet, ze_result_t, ZE_RESULT_SUCCESS, (uint32_t *, zet_metric_handle_t *));
+    ADDMETHOD_NOBASE(calculateMetricValues, ze_result_t, ZE_RESULT_SUCCESS, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, zet_typed_value_t *));
+    ADDMETHOD_NOBASE(calculateMetricValuesExp, ze_result_t, ZE_RESULT_SUCCESS, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, uint32_t *, uint32_t *, zet_typed_value_t *));
+    ADDMETHOD_NOBASE(activate, bool, true, ());
+    ADDMETHOD_NOBASE(deactivate, bool, true, ());
 
-    MOCK_METHOD(ze_result_t, metricGet, (uint32_t *, zet_metric_handle_t *), (override));
-    MOCK_METHOD(ze_result_t, calculateMetricValues, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, zet_typed_value_t *), (override));
-    MOCK_METHOD(ze_result_t, calculateMetricValuesExp, (const zet_metric_group_calculation_type_t, size_t, const uint8_t *, uint32_t *, uint32_t *, uint32_t *, zet_typed_value_t *), (override));
-    MOCK_METHOD(ze_result_t, getProperties, (zet_metric_group_properties_t * properties), (override));
-    MOCK_METHOD(bool, activate, (), (override));
-    MOCK_METHOD(bool, deactivate, (), (override));
     zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override {
         return nullptr;
     }
-    MOCK_METHOD(ze_result_t, waitForReports, (const uint32_t));
+
-    MOCK_METHOD(ze_result_t, openIoStream, (uint32_t &, uint32_t &));
+    ze_result_t getProperties(zet_metric_group_properties_t *properties) override {
-    MOCK_METHOD(ze_result_t, readIoStream, (uint32_t &, uint8_t &));
+        if (getPropertiesOutProperties) {
-    MOCK_METHOD(ze_result_t, closeIoStream, ());
+            *properties = *getPropertiesOutProperties;
+        }
+        return getPropertiesResult;
+    }
+
+    zet_metric_group_properties_t *getPropertiesOutProperties = nullptr;
+    ze_result_t getPropertiesResult = ZE_RESULT_SUCCESS;
 };
 
 struct MetricGroupImpTest : public OaMetricGroupImp {

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp

@@ -12,22 +12,15 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include <unordered_map>
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 using MetricEnumerationTest = Test<MetricContextFixture>;
 TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetricGroupIsCalledThenNoMetricGroupsAreReturned) {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->openAdapterGroup = [](MetricsDiscovery::IAdapterGroupLatest **) -> TCompletionCode { return TCompletionCode::CC_ERROR_GENERAL; };
 
     uint32_t metricGroupCount = 0;
@@ -37,9 +30,6 @@ TEST_F(MetricEnumerationTest, givenIncorrectMetricsDiscoveryDeviceWhenZetGetMetr
 
 TEST_F(MetricEnumerationTest, givenCorrectMetricDiscoveryWhenLoadMetricsDiscoveryIsCalledThenReturnsSuccess) {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1);
-
     EXPECT_EQ(mockMetricEnumeration->loadMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
 
@@ -1799,13 +1789,10 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeWhenZetMetricGroupCalcula
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
     EXPECT_EQ(metricGroupCount, 1u);
@@ -1861,13 +1848,10 @@ TEST_F(MetricEnumerationTest, givenFailedCalculateMetricsWhenZetMetricGroupCalcu
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsResult = TCompletionCode::CC_ERROR_GENERAL;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
-
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
     EXPECT_EQ(metricGroupCount, 1u);
@@ -1988,13 +1972,10 @@ TEST_F(MetricEnumerationTest, givenCorrectRawDataHeaderWhenZetMetricGroupCalcula
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -2131,16 +2112,13 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndLowerProvidedCalculate
     metricsConcurrentGroup.GetParamsResult = &metricsConcurrentGroupParams;
     metricsConcurrentGroup.getMetricSetResult = &metricsSet;
 
+    uint32_t returnedMetricCount = 2;
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    uint32_t returnedMetricCount = 2;
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -2198,10 +2176,6 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(Return(TCompletionCode::CC_OK));
-
     metric.GetParamsResult = &metricParams;
 
     // Metric group handles.
@@ -2259,10 +2233,7 @@ TEST_F(MetricEnumerationTest, givenCorrectRawReportSizeAndCorrectCalculatedRepor
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
-
+    metricsSet.calculateMetricsOutReportCount = &metricsSetParams.MetricsCount;
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<4>(metricsSetParams.MetricsCount), Return(TCompletionCode::CC_OK)));
 
     metric.GetParamsResult = &metricParams;
 
@@ -2342,7 +2313,8 @@ TEST_F(MetricEnumerationTest, givenIncorrectCalculationTypeWhenZetMetricGroupCal
 TEST_F(MetricEnumerationTest, givenInitializedMetricEnumerationWhenIsInitializedIsCalledThenMetricEnumerationWillNotBeInitializedAgain) {
 
     mockMetricEnumeration->initializationState = ZE_RESULT_SUCCESS;
-    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+    mockMetricEnumeration->isInitializedCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->isInitialized(), true);
 }
 
 TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitializedIsCalledThenMetricEnumerationWillBeInitialized) {
@@ -2382,19 +2354,12 @@ TEST_F(MetricEnumerationTest, givenNotInitializedMetricEnumerationWhenIsInitiali
     metric.GetParamsResult = &metricParams;
 
     mockMetricEnumeration->initializationState = ZE_RESULT_ERROR_UNINITIALIZED;
-    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+    mockMetricEnumeration->isInitializedCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->isInitialized(), true);
 }
 
 TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLibraryInitializedWhenLoadDependenciesThenReturnSuccess) {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
     mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
 
     auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
@@ -2404,9 +2369,7 @@ TEST_F(MetricEnumerationTest, givenLoadedMetricsLibraryAndDiscoveryAndMetricsLib
 
 TEST_F(MetricEnumerationTest, givenNotLoadedMetricsLibraryAndDiscoveryWhenLoadDependenciesThenReturnFail) {
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+    mockMetricEnumeration->loadMetricsDiscoveryResult = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE));
 
     auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
     EXPECT_EQ(metricSource.loadDependencies(), false);
@@ -2420,19 +2383,9 @@ TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLeg
     Mock<IAdapter_1_9> mockAdapter;
     Mock<IMetricsDevice_1_5> mockDevice;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
+    mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
 
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
     mockAdapter.openMetricsDeviceOutDevice = &mockDevice;
 
     setupDefaultMocksForMetricDevice(mockDevice);
@@ -2443,7 +2396,8 @@ TEST_F(MetricEnumerationTest, givenRootDeviceWhenLoadDependenciesIsCalledThenLeg
 
     EXPECT_EQ(metricSource.loadDependencies(), true);
     EXPECT_EQ(metricSource.isInitialized(), true);
-    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+    mockMetricEnumeration->isInitializedCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->isInitialized(), true);
     EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp

@@ -12,12 +12,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 using MetricEnumerationTest = Test<MetricContextFixture>;
@@ -141,19 +137,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
     Mock<IAdapter_1_9> mockAdapter;
     Mock<IMetricsDevice_1_5> mockDevice;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
-
+    mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
 
     mockAdapter.openMetricsSubDeviceOutDevice = &mockDevice;
     mockAdapter.openMetricsDeviceOutDevice = &mockDevice;
@@ -166,7 +151,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
 
     EXPECT_EQ(metricSource.loadDependencies(), true);
     EXPECT_EQ(metricSource.isInitialized(), true);
-    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), true);
+    mockMetricEnumeration->isInitializedCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->isInitialized(), true);
     EXPECT_EQ(mockMetricEnumeration->cleanupMetricsDiscovery(), ZE_RESULT_SUCCESS);
 }
 
@@ -182,9 +168,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
 
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[1], getMetricsAdapter())
+    mockMetricEnumerationSubDevices[1]->getMetricsAdapterResult = &mockAdapter;
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
 
     mockAdapter.openMetricsSubDeviceOutDevice = &mockDevice;
 
@@ -204,10 +188,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
     Mock<IAdapter_1_9> mockAdapter;
     Mock<IMetricsDevice_1_5> mockDevice;
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
-
+    mockMetricEnumerationSubDevices[1]->getMetricsAdapterResult = &mockAdapter;
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[1], getMetricsAdapter())
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
 
     mockAdapter.openMetricsSubDeviceOutDevice = &mockDevice;
 
@@ -226,18 +207,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
     Mock<IAdapter_1_9> mockAdapter;
     Mock<IMetricsDevice_1_5> mockDevice;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
-
+    mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
 
     mockAdapter.openMetricsSubDeviceResult = TCompletionCode::CC_ERROR_GENERAL;
 
@@ -247,7 +218,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
 
     EXPECT_EQ(metricSource.loadDependencies(), true);
     EXPECT_EQ(metricSource.isInitialized(), true);
-    EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
+    mockMetricEnumeration->isInitializedCallBase = true;
+    EXPECT_EQ(mockMetricEnumeration->isInitialized(), false);
     EXPECT_EQ(0u, mockDevice.GetParamsCalled);
 }
 
@@ -259,19 +231,9 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesAndO
     Mock<IAdapter_1_9> mockAdapter;
     Mock<IMetricsDevice_1_5> mockDevice;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&mockAdapterGroup);
 
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
+    mockMetricEnumeration->getMetricsAdapterResult = &mockAdapter;
-        .Times(1)
-        .WillOnce(Return(&mockAdapter));
 
     mockAdapter.openMetricsSubDeviceOutDevice = &mockDevice;
     mockAdapter.openMetricsDeviceResult = TCompletionCode::CC_ERROR_GENERAL;
@@ -471,13 +433,10 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenZetMetricG
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -700,13 +659,10 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenErrorGeneralOnCalculateMetricsWhen
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsResult = TCompletionCode::CC_ERROR_GENERAL;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(1)
-        .WillOnce(Return(TCompletionCode::CC_ERROR_GENERAL));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -851,13 +807,10 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenFirstSubDe
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(subDeviceCount - 1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -935,13 +888,10 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenSecondSubD
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(subDeviceCount - 1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -1020,9 +970,6 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(0);
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -1093,10 +1040,6 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
     metricsSet.GetMetricResult = &metric;
 
     metric.GetParamsResult = &metricParams;
-
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(0);
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
@@ -1178,9 +1121,6 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenCorrectRawDataHeaderWhenBothSubDev
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(0);
-
     // Metric group handles.
     uint32_t metricGroupCount = 1;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_export.cpp

@@ -13,13 +13,9 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "metrics_discovery_api.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 static const char *equationName = "EquationElement";
@@ -1046,4 +1042,4 @@ TEST_F(MetricExportDataOaTest, givenErrorDuringExportingPhaseWhenMetricGroupGetE
 }
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_initialization.cpp

@@ -11,11 +11,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::Return;
-
 namespace L0 {
 
 extern _ze_driver_handle_t *GlobalDriverHandle;
@@ -52,13 +49,6 @@ using MetricInitializationTest = Test<MetricContextFixture>;
 TEST_F(MetricInitializationTest, GivenOaDependenciesAreAvailableThenMetricInitializationIsSuccess) {
 
     GlobalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
     OaMetricSourceImp::osLibraryLoadFunction = MockOsLibrary::load;
     EXPECT_EQ(device->getMetricDeviceContext().enableMetricApi(), ZE_RESULT_SUCCESS);
     OaMetricSourceImp::osLibraryLoadFunction = NEO::OsLibrary::load;

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_1.cpp

@@ -13,12 +13,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateIsCalledThenQueryPoolIsObtained) {
@@ -42,40 +38,11 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateIsC
     QueryHandle_1_0 queryHandle = {&value};
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = queryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(queryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
     EXPECT_NE(poolHandle, nullptr);
@@ -102,33 +69,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectMetricGroupTypeWhenZetMetricQueryPoolC
 
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(0);
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
     EXPECT_EQ(poolHandle, nullptr);
@@ -155,40 +96,11 @@ TEST_F(MetricQueryPoolTest, givenIncorrectParameterWhenZetMetricQueryPoolCreateI
     QueryHandle_1_0 queryHandle = {&value};
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = queryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterResult = StatusCode::Failed;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(queryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Failed));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
     EXPECT_EQ(poolHandle, nullptr);
@@ -208,24 +120,9 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextWhenZetMetricQueryPoolCreateIsC
     poolDesc.count = 1;
     poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateResult = StatusCode::Failed;
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Failed));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
     EXPECT_EQ(poolHandle, nullptr);
@@ -245,20 +142,9 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextDataWhenZetMetricQueryPoolCreat
     poolDesc.count = 1;
     poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->getContextDataResult = false;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(false));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
     EXPECT_EQ(poolHandle, nullptr);
@@ -285,40 +171,11 @@ TEST_F(MetricQueryPoolTest, givenIncorrectGpuReportSizeWhenZetMetricQueryPoolCre
     QueryHandle_1_0 queryHandle = {&value};
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = queryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(queryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
     EXPECT_EQ(poolHandle, nullptr);
@@ -347,40 +204,11 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryCreateIsCalle
     QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
     ContextHandle_1_0 metricsLibraryContextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -417,40 +245,11 @@ TEST_F(MetricQueryPoolTest, givenIncorrectSlotIndexWhenZetMetricQueryCreateIsCal
     QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
     ContextHandle_1_0 metricsLibraryContextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -487,40 +286,11 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryResetIsCalled
     QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
     ContextHandle_1_0 metricsLibraryContextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -560,40 +330,11 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
     QueryHandle_1_0 metricsLibraryQueryHandle = {&value};
     ContextHandle_1_0 metricsLibraryContextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -640,48 +381,12 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -806,48 +511,12 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -918,48 +587,12 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -1034,48 +667,12 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetMetricQueryGetDataIsCa
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -1152,56 +749,14 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
+    mockMetricsLibrary->getMetricQueryReportSizeOutSize = reportSize;
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary, getMetricQueryReportSize(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(reportSize), Return(true)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -1243,15 +798,6 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
 }
 
-MATCHER_P(reportDataAreEqual, reportData, "") {
-    return (arg->Query.Slot == reportData->Query.Slot) &&
-           (arg->Query.SlotsCount == reportData->Query.SlotsCount) &&
-           (arg->Query.Handle.data == reportData->Query.Handle.data) &&
-           (arg->Query.Data == reportData->Query.Data) &&
-           (arg->Query.DataSize == reportData->Query.DataSize) &&
-           (arg->Type == reportData->Type);
-}
-
 TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCalledThenReturnsSuccessWithProperFilledStructure) {
 
     zet_device_handle_t metricDevice = device->toHandle();
@@ -1304,56 +850,15 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     reportData.Query.Slot = queriesCount - 1;
     reportData.Query.SlotsCount = 1;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
+    mockMetricsLibrary->g_mockApi->getDataExpectedData = &reportData;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
+    mockMetricsLibrary->getMetricQueryReportSizeOutSize = reportSize;
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary, getMetricQueryReportSize(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(reportSize), Return(true)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(reportDataAreEqual(&reportData)))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Create metric query pool.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp

@@ -14,12 +14,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPoolIsNotAvailable) {
@@ -68,9 +64,6 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool
     QueryHandle_1_0 queryHandle = {&value};
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
     openMetricsAdapter();
 
     setupDefaultMocksForMetricDevice(metricsDevice);
@@ -118,9 +111,6 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWhenZetMetricQueryPoolCreateI
     poolDesc.count = 1;
     poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
     EXPECT_NE(poolHandle, nullptr);
     EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);
@@ -150,32 +140,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWhenAppendMetricQueryBeginAnd
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(3)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(3)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
     EXPECT_EQ(zetMetricQueryCreate(poolHandle, 0, &queryHandle), ZE_RESULT_SUCCESS);
@@ -214,32 +180,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndCompletionEventWhenAppendM
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     ze_event_pool_handle_t eventPoolHandle = {};
     ze_event_pool_desc_t eventPoolDesc = {};
@@ -313,32 +255,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWithImmediateCommandListDefau
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     ze_event_pool_handle_t eventPoolHandle = {};
     ze_event_pool_desc_t eventPoolDesc = {};
@@ -410,32 +328,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeWithImmediateCommandListDefau
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     ze_event_pool_handle_t eventPoolHandle = {};
     ze_event_pool_desc_t eventPoolDesc = {};
@@ -493,28 +387,8 @@ TEST_F(MetricQueryPoolTest, givenExecutionQueryTypeAndMetricsLibraryWillFailWhen
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeResult = StatusCode::Failed;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Failed)));
 
     ze_event_pool_handle_t eventPoolHandle = {};
     ze_event_pool_desc_t eventPoolDesc = {};
@@ -579,9 +453,7 @@ TEST_F(MetricQueryPoolTest, givenUninitializedMetricEnumerationWhenGetQueryRepor
     auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
     auto &metricsLibrary = metricSource.getMetricsLibrary();
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricEnumeration->isInitializedResult = false;
-        .Times(1)
-        .WillOnce(Return(false));
 
     const uint32_t invalidSize = metricsLibrary.getQueryReportGpuSize();
 
@@ -642,40 +514,10 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalle
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->configurationCreateOutHandle = metricsLibraryConfigurationHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->configurationActivationCounter = 1;
-
+    mockMetricsLibrary->g_mockApi->configurationDeactivationCounter = 1;
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryConfigurationHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp

@@ -14,12 +14,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -48,40 +44,11 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricQueryPoolDestroyIs
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(2)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(2)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle[0]), ZE_RESULT_SUCCESS);
     EXPECT_NE(poolHandle[0], nullptr);
@@ -168,36 +135,9 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricGroupDeactivateIsC
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(metricDevice, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
@@ -290,8 +230,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenSubDeviceWithWorkloadPartitionWhenGe
 TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateIsCalledThenReturnsSuccess) {
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
-    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -350,38 +288,9 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPo
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-            .WillOnce(Return(true));
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -557,36 +466,9 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
@@ -631,32 +513,8 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm
     CommandBufferSize_1_0 commandBufferSize = {};
     commandBufferSize.GpuMemorySize = 100;
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     EXPECT_EQ(zetCommandListAppendMetricMemoryBarrier(commandListHandle), ZE_RESULT_SUCCESS);
 }
@@ -664,8 +522,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm
 TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMetricQueryPoolCreateIsCalledThenReturnFail) {
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
-    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -723,38 +579,10 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMe
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateResults.push_back(StatusCode::Failed);
-            .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->queryCreateResults.push_back(StatusCode::Success);
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)))
-        .WillOnce(Return(StatusCode::Failed));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -782,9 +610,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenExecutionQueryTypeWhenZetMetricQuery
     poolDesc.count = 1;
     poolDesc.type = ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, nullptr, &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
     EXPECT_NE(poolHandle, nullptr);
     EXPECT_EQ(zetMetricQueryPoolDestroy(poolHandle), ZE_RESULT_SUCCESS);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp

@@ -11,12 +11,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -89,46 +85,17 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa
     metric.GetParamsResult = &metricParams;
 
     for (uint32_t i = 0; i < subDeviceCount; ++i) {
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
-            .Times(1)
-            .WillOnce(Return(true));
 
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
+        mockMetricsLibrarySubDevices[i]->getMetricQueryReportSizeOutSize = reportSize;
-            .Times(1)
-            .WillOnce(Return(true));
     }
 
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getMetricQueryReportSize(_))
+    mockMetricsLibrary->getMetricQueryReportSizeOutSize = reportSize;
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(reportSize), Return(true)));
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(0);
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
+    mockMetricsLibrary->g_mockApi->getDataResults.push_back(StatusCode::Failed);
-        .Times(subDeviceCount)
+    mockMetricsLibrary->g_mockApi->getDataResults.push_back(StatusCode::Success);
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(_))
-        .Times(subDeviceCount)
-        .WillOnce(Return(StatusCode::Success))
-        .WillOnce(Return(StatusCode::Failed));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -167,8 +134,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa
 TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQueryBeginEndIsCalledThenReturnsSuccess) {
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
-    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, devices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
@@ -247,46 +212,10 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-            .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(2 * subDeviceCount + 1)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(2 * subDeviceCount + 1)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -338,8 +267,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp
 TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCommandListAppendMetricQueryBeginIsCalledThenReturnsFail) {
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
-    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, devices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
@@ -405,42 +332,10 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-            .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -471,8 +366,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo
 TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetCommandListAppendMetricQueryBeginIsCalledThenReturnsFail) {
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
-    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     ze_result_t returnValue;
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, devices[0], NEO::EngineGroupType::RenderCompute, 0u, returnValue));
@@ -538,46 +431,11 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-            .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->commandBufferGetResult = StatusCode::Failed;
-
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(1)
-        .WillRepeatedly(Return(StatusCode::Failed));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp

@@ -9,12 +9,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_query_pool_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 TEST_F(MultiDeviceMetricQueryPoolTest, givenUninitializedMetricsLibraryWhenGetGpuCommandsIsCalledThenReturnsFail) {
@@ -23,9 +19,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenUninitializedMetricsLibraryWhenGetGp
     auto &metricsLibrary = metricSource.getMetricsLibrary();
     CommandBufferData_1_0 commandBuffer = {};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricEnumeration->isInitializedResult = false;
-        .Times(1)
-        .WillOnce(Return(false));
 
     const bool result = metricsLibrary.getGpuCommands(commandBuffer);
 
@@ -98,53 +92,20 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
     for (uint32_t i = 0; i < subDeviceCount; ++i) {
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
-            .Times(1)
-            .WillOnce(Return(true));
 
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
+        mockMetricsLibrarySubDevices[i]->getMetricQueryReportSizeOutSize = metricsSetParams.QueryReportSize;
-            .Times(1)
-            .WillOnce(Return(true));
     }
 
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getMetricQueryReportSize(_))
+    mockMetricsLibrary->getMetricQueryReportSizeOutSize = metricsSetParams.QueryReportSize;
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(metricsSetParams.QueryReportSize), Return(true)));
 
-    EXPECT_CALL(*mockMetricsLibrary, load())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        .Times(0);
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetData(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -248,42 +209,10 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->configurationCreateOutHandle = metricsLibraryConfigurationHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->configurationActivationCounter = subDeviceCount;
-            .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->configurationDeactivationCounter = subDeviceCount;
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryConfigurationHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationActivate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDeactivate(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockConfigurationDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -309,7 +238,6 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric
 
     zet_device_handle_t metricDevice = devices[0]->toHandle();
     auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
-    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -368,38 +296,9 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric
 
     metric.GetParamsResult = &metricParams;
 
-    for (uint32_t i = 0; i < subDeviceCount; ++i) {
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = metricsLibraryContextHandle;
-        EXPECT_CALL(*mockMetricEnumerationSubDevices[i], isInitialized())
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = metricsLibraryQueryHandle;
-            .Times(1)
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-            .WillOnce(Return(true));
-
-        EXPECT_CALL(*mockMetricsLibrarySubDevices[i], getContextData(_, _))
-            .Times(1)
-            .WillOnce(Return(true));
-    }
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(metricsLibraryQueryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<2>(metricsLibraryContextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(subDeviceCount)
-        .WillRepeatedly(Return(StatusCode::Success));
 
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp

@@ -13,12 +13,8 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -43,9 +39,7 @@ TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenI
 
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
-    EXPECT_CALL(metricGroup, getProperties(_))
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
 
     // Metric streamer open.
     EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_ERROR_INVALID_ARGUMENT);
@@ -87,14 +81,6 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
 
     openMetricsAdapter();
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
     setupDefaultMocksForMetricDevice(metricsDevice);
 
     metricsDevice.getConcurrentGroupResults.push_back(&metricsConcurrentGroup);
@@ -169,14 +155,6 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa
 
     openMetricsAdapter();
 
-    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
-        .Times(1)
-        .WillOnce(Return(ZE_RESULT_SUCCESS));
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(1)
-        .WillOnce(Return(true));
-
     setupDefaultMocksForMetricDevice(metricsDevice);
 
     metricsDevice.getConcurrentGroupResults.push_back(&metricsConcurrentGroup);
@@ -389,40 +367,11 @@ TEST_F(MetricStreamerTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateExtI
     QueryHandle_1_0 queryHandle = {&value};
     ContextHandle_1_0 contextHandle = {&value};
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    metricGroup.getPropertiesOutProperties = &metricGroupProperties;
-        .Times(1)
-        .WillOnce(Return(true));
 
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->queryCreateOutHandle = queryHandle;
-        .WillOnce(Return(true));
+    mockMetricsLibrary->g_mockApi->getParameterOutValue = value;
-
-    EXPECT_CALL(*mockMetricsLibrary, load())
-        .Times(0);
-
-    EXPECT_CALL(metricGroup, getProperties(_))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(metricGroupProperties), Return(ZE_RESULT_SUCCESS)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryCreate(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(queryHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockQueryDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockGetParameter(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(value), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     // Metric query pool create.
     EXPECT_EQ(zetMetricQueryPoolCreate(context->toHandle(), metricDevice, metricGroup.toHandle(), &poolDesc, &poolHandle), ZE_RESULT_SUCCESS);
@@ -757,15 +706,6 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt
     EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
 }
 
-MATCHER_P(streamerMarkerDataAreEqual, marker, "") {
-    const uint32_t streamerMarkerLowBitsMask = 0x1FFFFFF;
-    const uint32_t streamerMarkerHighBitsShift = 25;
-
-    return (arg->CommandsType == ObjectType::MarkerStreamUser) &&
-           (arg->MarkerStreamUser.Value == (marker & streamerMarkerLowBitsMask)) &&
-           (arg->MarkerStreamUser.Reserved == (marker >> streamerMarkerHighBitsShift));
-}
-
 TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStreamerMarkerIsCalledThenReturnsSuccess) {
 
     // One api: device handle.
@@ -823,21 +763,8 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
 
     openMetricsAdapter();
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
@@ -848,14 +775,6 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
 
     metricsSet.GetParamsResult = &metricsSetParams;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(streamerMarkerDataAreEqual(markerValue)))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
-
     // Metric group count.
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
@@ -943,21 +862,8 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
 
     openMetricsAdapter();
 
-    EXPECT_CALL(*mockMetricEnumeration, isInitialized())
+    mockMetricsLibrary->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrary->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary, getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
@@ -968,14 +874,6 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
 
     metricsSet.GetParamsResult = &metricsSetParams;
 
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(10)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrary->g_mockApi, MockCommandBufferGet(_))
-        .Times(10)
-        .WillRepeatedly(Return(StatusCode::Success));
-
     // Metric group count.
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp

@@ -12,9 +12,6 @@
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -187,15 +184,10 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetri
     metricsSetParams.ShortName = "Metric set description";
     metricsSetParams.RawReportSize = 256;
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], loadMetricsDiscovery())
-        .Times(0);
-
     mockMetricEnumeration->globalMockApi->adapterGroup = reinterpret_cast<IAdapterGroupLatest *>(&adapterGroup);
     adapter.openMetricsDeviceOutDevice = &metricsDevice;
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], getMetricsAdapter())
+    mockMetricEnumerationSubDevices[0]->getMetricsAdapterResult = &adapter;
-        .Times(1)
-        .WillOnce(Return(&adapter));
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
@@ -638,29 +630,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetComman
 
     openMetricsAdapter();
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
+    mockMetricsLibrarySubDevices[0]->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrarySubDevices[0]->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(10)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGet(_))
-        .Times(10)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp

@@ -11,9 +11,6 @@
 #include "level_zero/core/source/cmdlist/cmdlist.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -70,29 +67,8 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma
 
     openMetricsAdapterSubDevice(0);
 
-    EXPECT_CALL(*mockMetricEnumerationSubDevices[0], isInitialized())
+    mockMetricsLibrarySubDevices[0]->g_mockApi->contextCreateOutHandle = contextHandle;
-        .Times(1)
+    mockMetricsLibrarySubDevices[0]->g_mockApi->commandBufferGetSizeOutSize = commandBufferSize;
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGetSize(_, _))
-        .Times(10)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(::testing::ByRef(commandBufferSize)), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockCommandBufferGet(_))
-        .Times(10)
-        .WillRepeatedly(Return(StatusCode::Success));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0], getContextData(_, _))
-        .Times(1)
-        .WillOnce(Return(true));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextCreate(_, _, _))
-        .Times(1)
-        .WillOnce(DoAll(::testing::SetArgPointee<2>(contextHandle), Return(StatusCode::Success)));
-
-    EXPECT_CALL(*mockMetricsLibrarySubDevices[0]->g_mockApi, MockContextDelete(_))
-        .Times(1)
-        .WillOnce(Return(StatusCode::Success));
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
@@ -174,13 +150,10 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricGroupCalcu
 
     metricsSet.GetParamsResult = &metricsSetParams;
     metricsSet.GetMetricResult = &metric;
+    metricsSet.calculateMetricsOutReportCount = &returnedMetricCount;
 
     metric.GetParamsResult = &metricParams;
 
-    EXPECT_CALL(metricsSet, CalculateMetrics(_, _, _, _, _, _, _))
-        .Times(subDeviceCount)
-        .WillRepeatedly(DoAll(::testing::SetArgPointee<4>(returnedMetricCount), Return(TCompletionCode::CC_OK)));
-
     uint32_t metricGroupCount = 0;
     EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
     EXPECT_EQ(metricGroupCount, 1u);

level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_oa_enumeration_windows.cpp

@@ -11,12 +11,8 @@
 
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using ::testing::_;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -48,13 +44,10 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
     adapterGroup.GetAdapterResult = &adapter;
     adapter.GetParamsResult = &adapterParams;
 
-    EXPECT_CALL(*mockMetricEnumeration, getAdapterId(_, _))
+    mockMetricEnumeration->getAdapterIdOutMajor = adapterParams.SystemId.Luid.HighPart;
-        .Times(1)
+    mockMetricEnumeration->getAdapterIdOutMinor = adapterParams.SystemId.Luid.LowPart;
-        .WillOnce(DoAll(::testing::SetArgReferee<0>(adapterParams.SystemId.Luid.HighPart), ::testing::SetArgReferee<1>(adapterParams.SystemId.Luid.LowPart), Return(true)));
 
-    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
+    mockMetricEnumeration->getMetricsAdapterResult = &adapter;
-        .Times(1)
-        .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
 

level_zero/tools/test/unit_tests/sources/sysman/ecc/windows/mock_ecc.h

@@ -25,7 +25,7 @@ struct Mock<EccFwInterface> : public EccFwInterface {
     uint8_t mockCurrentState = 0;
     uint8_t mockPendingState = 0;
 
-    ze_result_t fwDeviceInit() {
+    ze_result_t fwDeviceInit() override {
         return mockFwDeviceInit;
     }
 

level_zero/tools/test/unit_tests/sources/sysman/ecc/windows/test_zes_ecc.cpp

@@ -11,9 +11,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::Matcher;
-using ::testing::NiceMock;
-
 namespace L0 {
 namespace ult {
 
@@ -32,7 +29,7 @@ class ZesEccFixture : public SysmanDeviceFixture {
         }
         SysmanDeviceFixture::SetUp();
         pFwUtilInterfaceOld = pWddmSysmanImp->pFwUtilInterface;
-        pMockFwInterface = std::make_unique<NiceMock<Mock<EccFwInterface>>>();
+        pMockFwInterface = std::make_unique<Mock<EccFwInterface>>();
         pWddmSysmanImp->pFwUtilInterface = pMockFwInterface.get();
 
         pEccImp = static_cast<L0::EccImp *>(pSysmanDeviceImp->pEcc);

level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -24,7 +24,7 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
     uint32_t mockFrequencyTimeStamp = 38400000;
     uint32_t mockFrequencyActivity = 1200000;
 
-    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
 
@@ -71,9 +71,6 @@ struct Mock<EngineKmdSysManager> : public EngineKmdSysManager {
     }
 
     void setActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
-        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
-        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
-
         pResponse->outDataSize = 0;
         pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
     }

level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_zes_engine.cpp

@@ -81,14 +81,14 @@ TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGr
     pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     uint32_t count = 0;
     EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
-    EXPECT_EQ(count, 0);
+    EXPECT_EQ(count, 0u);
 }
 
 TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsIfEngineSupportIsAbsentThenZeroHandlesAreReturned) {
     pKmdSysManager->mockNumSupportedEngineGroups = 0;
     uint32_t count = 0;
     EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
-    EXPECT_EQ(count, 0);
+    EXPECT_EQ(count, 0u);
 }
 
 TEST_F(SysmanDeviceEngineFixture, GivenUnsupportedEngineHandleWhenGettingEngineActivityThenFailureIsReturned) {
@@ -107,8 +107,8 @@ TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetPropertiesThenCorrectEngine
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
-        EXPECT_EQ(properties.type, pKmdSysManager->mockEngineTypes[engineGroupIndex++]);
+        EXPECT_EQ(static_cast<uint32_t>(properties.type), static_cast<uint32_t>(pKmdSysManager->mockEngineTypes[engineGroupIndex++]));
     }
 }
 

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/mock_fabric_device.h

@@ -11,8 +11,6 @@
 #include "level_zero/tools/source/sysman/linux/fs_access.h"
 #include "level_zero/tools/source/sysman/linux/os_sysman_imp.h"
 
-#include "gmock/gmock.h"
-
 namespace L0 {
 namespace ult {
 

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp

@@ -9,7 +9,6 @@
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include <limits>

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp

@@ -12,7 +12,6 @@
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include <limits>

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_zes_fabric_port.cpp

@@ -8,7 +8,6 @@
 #include "level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/mock_fabric_device.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include <limits>

level_zero/tools/test/unit_tests/sources/sysman/fabric_port/windows/test_zes_fabric_port.cpp

@@ -13,8 +13,6 @@ extern bool sysmanUltsEnable;
 namespace L0 {
 namespace ult {
 
-constexpr auto maxNumPorts = 32u;
-
 class SysmanFabricPortFixture : public SysmanDeviceFixture {
   protected:
     std::unique_ptr<FabricDeviceImp> pFabricDevice;

level_zero/tools/test/unit_tests/sources/sysman/fan/windows/test_zes_sysman_fan.cpp

@@ -102,9 +102,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowS
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_TRUE(properties.canControl);
-        EXPECT_EQ(properties.maxPoints, pKmdSysManager->mockFanMaxPoints);
+        EXPECT_EQ(static_cast<uint32_t>(properties.maxPoints), pKmdSysManager->mockFanMaxPoints);
         EXPECT_EQ(properties.maxRPM, -1);
         EXPECT_EQ(properties.supportedModes, zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE);
         EXPECT_EQ(properties.supportedUnits, zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT);
@@ -147,9 +147,9 @@ TEST_F(SysmanDeviceFanFixture, GivenValidFanHandleWhenGettingFanPropertiesAllowS
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_TRUE(properties.canControl);
-        EXPECT_EQ(properties.maxPoints, pKmdSysManager->mockFanMaxPoints);
+        EXPECT_EQ(static_cast<uint32_t>(properties.maxPoints), pKmdSysManager->mockFanMaxPoints);
         EXPECT_EQ(properties.maxRPM, -1);
         EXPECT_EQ(properties.supportedModes, zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE);
         EXPECT_EQ(properties.supportedUnits, zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT);

level_zero/tools/test/unit_tests/sources/sysman/firmware/windows/test_zes_sysman_firmware.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -9,7 +9,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
 namespace L0 {
 namespace ult {
 

level_zero/tools/test/unit_tests/sources/sysman/firmware_util/mock_fw_util_fixture.h

@@ -13,8 +13,6 @@
 #include "level_zero/tools/source/sysman/firmware_util/firmware_util.h"
 #include "level_zero/tools/source/sysman/sysman.h"
 
-#include "gmock/gmock.h"
-
 using namespace NEO;
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency.cpp

@@ -7,7 +7,6 @@
 
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "mock_sysfs_frequency.h"
 

level_zero/tools/test/unit_tests/sources/sysman/frequency/windows/test_zes_frequency.cpp

@@ -104,7 +104,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequ
     pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNKNOWN;
     uint32_t count = 0;
     EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
-    EXPECT_EQ(count, 0);
+    EXPECT_EQ(count, 0u);
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyDomainsThenValidPowerHandlesIsReturned) {
@@ -206,7 +206,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCa
             EXPECT_EQ(numClocks, count);
         } else if (domainIndex == ZES_FREQ_DOMAIN_MEMORY) {
             EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
-            EXPECT_EQ(1, count);
+            EXPECT_EQ(1u, count);
         } else if (domainIndex == ZES_FREQ_DOMAIN_MEDIA) {
             EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
             EXPECT_EQ(numClocks, count);
@@ -489,52 +489,43 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyCallSucceeds) {
     pKmdSysManager->allowSetCalls = false;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         zes_oc_mode_t mode = ZES_OC_MODE_OFF;
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &mode));
         EXPECT_DOUBLE_EQ(ZES_OC_MODE_INTERPOLATIVE, mode);
-        domainIndex++;
     }
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallFails) {
     pKmdSysManager->allowSetCalls = false;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         double freqTarget = 1400.0;
         EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
-        domainIndex++;
     }
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallFails) {
     pKmdSysManager->allowSetCalls = false;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         double voltageTarget = 1040.0, voltageOffset = 20.0;
         EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetVoltageTarget(handle, voltageTarget, voltageOffset));
-        domainIndex++;
     }
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToFalseWhenCallingzesFrequencyOcSetModeThenVerifyCallFails) {
     pKmdSysManager->allowSetCalls = false;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         zes_oc_mode_t mode = ZES_OC_MODE_OVERRIDE;
         EXPECT_NE(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
-        domainIndex++;
     }
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyCallSucceed) {
     pKmdSysManager->allowSetCalls = true;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         double freqTarget = 1400.0;
@@ -542,13 +533,11 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
         double newFreqTarget = 0.0;
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetFrequencyTarget(handle, &newFreqTarget));
         EXPECT_DOUBLE_EQ(newFreqTarget, freqTarget);
-        domainIndex++;
     }
 }
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyCallSucceed) {
     pKmdSysManager->allowSetCalls = true;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
         double voltageTarget = 1040.0, voltageOffset = 20.0;
@@ -557,7 +546,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetVoltageTarget(handle, &newVoltageTarget, &newVoltageOffset));
         EXPECT_DOUBLE_EQ(voltageTarget, newVoltageTarget);
         EXPECT_DOUBLE_EQ(voltageOffset, newVoltageOffset);
-        domainIndex++;
     }
 }
 
@@ -587,7 +575,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
 
 TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTrueWhenCallingzesFrequencyOcSetModeThenVerifyCallSucceed) {
     pKmdSysManager->allowSetCalls = true;
-    uint32_t domainIndex = 0;
     auto handles = get_frequency_handles(frequencyHandleComponentCount);
     for (auto handle : handles) {
 
@@ -616,8 +603,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAllowSetCallsToTru
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(handle, mode));
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(handle, &newmode));
         EXPECT_EQ(newmode, ZES_OC_MODE_OVERRIDE);
-
-        domainIndex++;
     }
 }
 

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp

@@ -9,6 +9,8 @@
 
 #include "level_zero/tools/source/sysman/linux/nl_api/iaf_nl_api.h"
 
+#include "gtest/gtest.h"
+
 namespace L0 {
 namespace ult {
 
@@ -296,4 +298,4 @@ ze_result_t MockIafNlApi::fportProperties(const IafPortId portId, uint64_t &neig
 }
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h

@@ -9,8 +9,6 @@
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/tools/source/sysman/linux/nl_api/iaf_nl_api.h"
 
-#include "gmock/gmock.h"
-
 #include <sstream>
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp

@@ -9,6 +9,8 @@
 
 #include "level_zero/tools/source/sysman/linux/nl_api/iaf_nl_api.h"
 
+#include "gtest/gtest.h"
+
 namespace L0 {
 namespace ult {
 

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h

@@ -11,8 +11,6 @@
 #include "level_zero/tools/source/sysman/linux/nl_api/iaf_nl_api.h"
 #include "level_zero/tools/source/sysman/linux/nl_api/nl_api.h"
 
-#include "gmock/gmock.h"
-
 #include <map>
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_dll.cpp

@@ -7,6 +7,7 @@
 
 #include "mock_nl_dll.h"
 
+#include "gtest/gtest.h"
 #include "iaf/iaf_netlink.h"
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_dll.h

@@ -9,8 +9,6 @@
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/tools/source/sysman/linux/nl_api/nl_api.h"
 
-#include "gmock/gmock.h"
-
 // Define opaque types so variables can be allocated
 struct nl_sock {
 };

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp

@@ -9,7 +9,7 @@
 
 #include "level_zero/tools/source/sysman/linux/nl_api/iaf_nl_api.h"
 
-#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 #include "mock_nl_api_prelim.h"
 
 #include <limits>

level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_nl_api.cpp

@@ -5,6 +5,7 @@
  *
  */
 
+#include "gtest/gtest.h"
 #include "iaf/iaf_netlink.h"
 #include "mock_nl_dll.h"
 

level_zero/tools/test/unit_tests/sources/sysman/linux/pmu/test_pmu.cpp

@@ -8,6 +8,8 @@
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/pmu/mock_pmu.h"
 
+#include <cmath>
+
 extern bool sysmanUltsEnable;
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/memory/windows/mock_memory.h

@@ -135,9 +135,6 @@ struct Mock<MemoryKmdSysManager> : public MemoryKmdSysManager {
     }
 
     void setMemoryProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
-        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
-        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
-
         pResponse->outDataSize = 0;
         pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
     }

level_zero/tools/test/unit_tests/sources/sysman/memory/windows/test_zes_memory.cpp

@@ -139,8 +139,8 @@ TEST_F(SysmanDeviceMemoryFixture, DISABLED_GivenValidMemoryHandleWhenCallingGett
         EXPECT_FALSE(properties.onSubdevice);
         EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_EQ(properties.physicalSize, pKmdSysManager->mockMemoryPhysicalSize);
-        EXPECT_EQ(properties.numChannels, pKmdSysManager->mockMemoryChannels);
+        EXPECT_EQ(static_cast<uint32_t>(properties.numChannels), pKmdSysManager->mockMemoryChannels);
-        EXPECT_EQ(properties.busWidth, pKmdSysManager->mockMemoryBus);
+        EXPECT_EQ(static_cast<uint32_t>(properties.busWidth), pKmdSysManager->mockMemoryBus);
     }
 }
 

level_zero/tools/test/unit_tests/sources/sysman/pci/windows/mock_pci.h

@@ -120,9 +120,6 @@ struct Mock<PciKmdSysManager> : public PciKmdSysManager {
     }
 
     void setPciProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
-        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
-        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
-
         pResponse->outDataSize = 0;
         pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
     }

level_zero/tools/test/unit_tests/sources/sysman/pci/windows/test_zes_pci.cpp

@@ -28,7 +28,7 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture {
 
         pMemoryManagerOld = device->getDriverHandle()->getMemoryManager();
 
-        pMemoryManager = new ::testing::NiceMock<MockMemoryManagerSysman>(*neoDevice->getExecutionEnvironment());
+        pMemoryManager = new MockMemoryManagerSysman(*neoDevice->getExecutionEnvironment());
 
         pMemoryManager->localMemorySupported[0] = false;
 
@@ -89,8 +89,8 @@ TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetP
     EXPECT_EQ(properties.address.bus, pKmdSysManager->mockBus[KmdSysman::PciDomainsType::PciRootPort]);
     EXPECT_EQ(properties.address.device, pKmdSysManager->mockDevice[KmdSysman::PciDomainsType::PciRootPort]);
     EXPECT_EQ(properties.address.function, pKmdSysManager->mockFunction[KmdSysman::PciDomainsType::PciRootPort]);
-    EXPECT_EQ(properties.maxSpeed.gen, pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(properties.maxSpeed.gen), pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
-    EXPECT_EQ(properties.maxSpeed.width, pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(properties.maxSpeed.width), pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
 }
 
 TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallinggetPciBdfAndkmdSysmanCallFailsThenUnknownValuesArereturned) {
@@ -102,10 +102,10 @@ TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallinggetPciBdfAndkmdS
     zes_pci_properties_t properties = {};
     WddmPciImp *pPciImp = new WddmPciImp(pOsSysman);
     EXPECT_EQ(ZE_RESULT_SUCCESS, pPciImp->getPciBdf(properties));
-    EXPECT_EQ(0, properties.address.domain);
+    EXPECT_EQ(0u, properties.address.domain);
-    EXPECT_EQ(0, properties.address.bus);
+    EXPECT_EQ(0u, properties.address.bus);
-    EXPECT_EQ(0, properties.address.device);
+    EXPECT_EQ(0u, properties.address.device);
-    EXPECT_EQ(0, properties.address.function);
+    EXPECT_EQ(0u, properties.address.function);
     delete pPciImp;
 }
 
@@ -121,8 +121,8 @@ TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetP
     EXPECT_EQ(properties.address.bus, pKmdSysManager->mockBus[KmdSysman::PciDomainsType::PciRootPort]);
     EXPECT_EQ(properties.address.device, pKmdSysManager->mockDevice[KmdSysman::PciDomainsType::PciRootPort]);
     EXPECT_EQ(properties.address.function, pKmdSysManager->mockFunction[KmdSysman::PciDomainsType::PciRootPort]);
-    EXPECT_EQ(properties.maxSpeed.gen, pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(properties.maxSpeed.gen), pKmdSysManager->mockMaxLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
-    EXPECT_EQ(properties.maxSpeed.width, pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(properties.maxSpeed.width), pKmdSysManager->mockMaxLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
 }
 
 TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingGetPciBdfAndRequestMultpileFailsThenFailureIsReturned) {
@@ -224,8 +224,8 @@ TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetS
     zes_pci_state_t state;
     ze_result_t result = zesDevicePciGetState(device, &state);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(state.speed.gen, pKmdSysManager->mockCurrentLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(state.speed.gen), pKmdSysManager->mockCurrentLinkSpeed[KmdSysman::PciDomainsType::PciRootPort]);
-    EXPECT_EQ(state.speed.width, pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
+    EXPECT_EQ(static_cast<uint32_t>(state.speed.width), pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciRootPort]);
 }
 
 TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsWithNoLocalMemoryThenVerifyzetSysmanPciGetBarsCallSucceeds) {
@@ -234,8 +234,8 @@ TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetS
     zes_pci_state_t state;
     ze_result_t result = zesDevicePciGetState(device, &state);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(state.speed.gen, pKmdSysManager->mockCurrentLinkSpeed[KmdSysman::PciDomainsType::PciCurrentDevice]);
+    EXPECT_EQ(static_cast<uint32_t>(state.speed.gen), pKmdSysManager->mockCurrentLinkSpeed[KmdSysman::PciDomainsType::PciCurrentDevice]);
-    EXPECT_EQ(state.speed.width, pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciCurrentDevice]);
+    EXPECT_EQ(static_cast<uint32_t>(state.speed.width), pKmdSysManager->mockCurrentLinkWidth[KmdSysman::PciDomainsType::PciCurrentDevice]);
 }
 
 TEST_F(SysmanDevicePciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStateThenValidCurrentMaxBandwidthIsReturned) {

level_zero/tools/test/unit_tests/sources/sysman/performance/linux/test_zes_performance_prelim.cpp

@@ -8,6 +8,10 @@
 #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/performance/linux/mock_sysfs_performance_prelim.h"
 
+#include "gtest/gtest.h"
+
+#include <cmath>
+
 extern bool sysmanUltsEnable;
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/power/windows/mock_power.h

@@ -36,7 +36,7 @@ struct Mock<PowerKmdSysManager> : public PowerKmdSysManager {
     uint64_t mockEnergyCounter64Bit = 32323232323232;
     uint32_t mockFrequencyTimeStamp = 38400000;
 
-    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
         uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
         pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
 

level_zero/tools/test/unit_tests/sources/sysman/power/windows/test_zes_sysman_power.cpp

@@ -122,12 +122,12 @@ TEST_F(SysmanDevicePowerFixture, DISABLED_GivenValidPowerHandleWhenGettingPowerP
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_TRUE(properties.canControl);
         EXPECT_TRUE(properties.isEnergyThresholdSupported);
-        EXPECT_EQ(properties.maxLimit, pKmdSysManager->mockMaxPowerLimit);
+        EXPECT_EQ(static_cast<uint32_t>(properties.maxLimit), pKmdSysManager->mockMaxPowerLimit);
-        EXPECT_EQ(properties.minLimit, pKmdSysManager->mockMinPowerLimit);
+        EXPECT_EQ(static_cast<uint32_t>(properties.minLimit), pKmdSysManager->mockMinPowerLimit);
-        EXPECT_EQ(properties.defaultLimit, pKmdSysManager->mockTpdDefault);
+        EXPECT_EQ(static_cast<uint32_t>(properties.defaultLimit), pKmdSysManager->mockTpdDefault);
     }
 }
 
@@ -144,12 +144,12 @@ TEST_F(SysmanDevicePowerFixture, DISABLED_GivenValidPowerHandleWhenGettingPowerP
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_FALSE(properties.canControl);
         EXPECT_FALSE(properties.isEnergyThresholdSupported);
-        EXPECT_EQ(properties.maxLimit, pKmdSysManager->mockMaxPowerLimit);
+        EXPECT_EQ(static_cast<uint32_t>(properties.maxLimit), pKmdSysManager->mockMaxPowerLimit);
-        EXPECT_EQ(properties.minLimit, pKmdSysManager->mockMinPowerLimit);
+        EXPECT_EQ(static_cast<uint32_t>(properties.minLimit), pKmdSysManager->mockMinPowerLimit);
-        EXPECT_EQ(properties.defaultLimit, pKmdSysManager->mockTpdDefault);
+        EXPECT_EQ(static_cast<uint32_t>(properties.defaultLimit), pKmdSysManager->mockTpdDefault);
     }
 }
 

level_zero/tools/test/unit_tests/sources/sysman/scheduler/windows/test_zes_sysman_scheduler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,7 +11,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
 namespace L0 {
 namespace ult {
 
@@ -101,4 +100,4 @@ TEST_F(ZesSchedulerFixture, GivenValidDeviceHandleWhenGettingSchedulerProperties
 }
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/mock_temperature.h

@@ -75,6 +75,8 @@ struct Mock<TemperatureKmdSysManager> : public TemperatureKmdSysManager {
             case KmdSysman::TemperatureDomainsType::TemperatureDomainHBM: {
                 *pValue = mockTempMemory;
             } break;
+            default:
+                break;
             }
             pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
             pResponse->outDataSize = sizeof(uint32_t);

level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp

@@ -99,7 +99,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidDeviceHandleWhenEnumeratingTemp
     uint32_t count = 0;
     pKmdSysManager->isIntegrated = true;
     EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
-    EXPECT_EQ(count, 0);
+    EXPECT_EQ(count, 0u);
 }
 
 TEST_F(SysmanDeviceTemperatureFixture, GivenValidPowerHandleWhenGettingTemperaturePropertiesAllowSetToTrueThenCallSucceeds) {
@@ -112,7 +112,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidPowerHandleWhenGettingTemperatu
 
         EXPECT_EQ(ZE_RESULT_SUCCESS, result);
         EXPECT_FALSE(properties.onSubdevice);
-        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.subdeviceId, 0u);
         EXPECT_FALSE(properties.isCriticalTempSupported);
         EXPECT_FALSE(properties.isThreshold1Supported);
         EXPECT_FALSE(properties.isThreshold2Supported);

level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h

@@ -9,8 +9,6 @@
 #include "level_zero/core/test/unit_tests/mock.h"
 #include "level_zero/tools/source/sysman/windows/kmd_sys_manager.h"
 
-#include "gmock/gmock.h"
-
 namespace L0 {
 namespace ult {
 
@@ -306,14 +304,14 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
         }
     }
 
-    ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out) {
+    ze_result_t requestSingle(KmdSysman::RequestProperty &In, KmdSysman::ResponseProperty &Out) override {
         if (mockRequestSingle == false) {
             return KmdSysManager::requestSingle(In, Out);
         }
         return mockRequestSingleResult;
     }
 
-    ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut) {
+    ze_result_t requestMultiple(std::vector<KmdSysman::RequestProperty> &vIn, std::vector<KmdSysman::ResponseProperty> &vOut) override {
         if (mockRequestMultiple == false) {
             return KmdSysManager::requestMultiple(vIn, vOut);
         } else {
@@ -422,7 +420,7 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
         }
     }
 
-    NTSTATUS escape(uint32_t escapeOp, uint64_t pInPtr, uint32_t dataInSize, uint64_t pOutPtr, uint32_t dataOutSize) {
+    NTSTATUS escape(uint32_t escapeOp, uint64_t pInPtr, uint32_t dataInSize, uint64_t pOutPtr, uint32_t dataOutSize) override {
         if (mockEscapeResult != STATUS_SUCCESS) {
             return mockEscapeResult;
         }

level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h

@@ -18,11 +18,8 @@
 #include "level_zero/tools/source/sysman/windows/os_sysman_imp.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/mocks/mock_sysman_env_vars.h"
 
-#include "gmock/gmock.h"
-
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
 using namespace NEO;
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/sysman/windows/test_sysman_manager.cpp

@@ -11,18 +11,10 @@
 #include "level_zero/tools/source/sysman/windows/os_sysman_imp.h"
 #include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h"
 
-#include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::Invoke;
-using ::testing::NiceMock;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 

opencl/test/unit_test/ult_specific_config_ocl.cpp

@@ -23,9 +23,6 @@ void cleanTestHelpers() {
     delete platformsImpl;
 }
 
-void initGTest(int &argc, char **argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-}
 bool isPlatformSupported(const HardwareInfo &hwInfoForTests) {
     return true;
 }

shared/test/common/common_main.cpp

@@ -72,7 +72,6 @@ extern PRODUCT_FAMILY productFamily;
 extern GFXCORE_FAMILY renderCoreFamily;
 
 void applyWorkarounds();
-void initGTest(int &argc, char **argv);
 bool isPlatformSupported(const HardwareInfo &hwInfoForTests);
 void setupTestFiles(std::string testBinaryFiles, int32_t revId);
 std::string getBaseExecutionDir();
@@ -165,7 +164,7 @@ int main(int argc, char **argv) {
     }
 #endif
 
-    initGTest(argc, argv);
+    ::testing::InitGoogleTest(&argc, argv);
     HardwareInfo hwInfoForTests = DEFAULT_TEST_PLATFORM::hwInfo;
 
     uint32_t euPerSubSlice = 0;

shared/test/unit_test/ult_specific_config.cpp

@@ -65,10 +65,6 @@ void applyWorkarounds() {
     }
 }
 
-void initGTest(int &argc, char **argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-}
-
 bool isPlatformSupported(const HardwareInfo &hwInfoForTests) {
     return true;
 }