Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove gmock from MockGmmResourceInfo

Browse Source 
Related-To: NEO-4914
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2021-11-29 22:47:31 +00:00
committed by Compute-Runtime-Automation
parent 830281f698
commit eb572bd61c
11 changed files with 58 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/test/unit_tests/mocks/mock_gmm_resource_info_l0.cpp
View File

@ -9,6 +9,8 @@
#include "level_zero/core/source/image/image_formats.h"
#include "gtest/gtest.h"
using namespace ::testing;
namespace NEO {

35
opencl/test/unit_test/d3d_sharing/d3d9_tests.cpp
View File

@ -84,7 +84,7 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test {
imgDesc.imageType = ImageType::Image2D;
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
gmm = MockGmm::queryImgParams(pPlatform->getClDevice(0)->getGmmClientContext(), imgInfo).release();
mockGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(gmm->gmmResourceInfo.get());
mockGmmResInfo = static_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
memoryManager->forceGmm = gmm;
}
@ -128,7 +128,7 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test {
cl_dx9_surface_info_khr surfaceInfo = {};
Gmm *gmm = nullptr;
NiceMock<MockGmmResourceInfo> *mockGmmResInfo = nullptr;
MockGmmResourceInfo *mockGmmResInfo = nullptr;
std::unique_ptr<MockMM> memoryManager;
};
@ -607,13 +607,13 @@ TEST_F(D3D9Tests, givenZeroSharedHandleAndNonLockableFlagWhenCreateThenCreateSta
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndEnabledInteropUserSyncWhenReleasingThenResourcesAreReleased) {
context->setInteropUserSyncEnabled(true);
surfaceInfo.shared_handle = (HANDLE)1;
mockGmmResInfo->cpuBltCalled = 0u;
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, getRenderTargetData(_, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, lockRect(_, _, _)).Times(0);
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
@ -631,18 +631,19 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndEnabledInteropUserSyncWhenReleasi
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncWhenReleasingThenResourcesAreReleased) {
context->setInteropUserSyncEnabled(false);
surfaceInfo.shared_handle = (HANDLE)1;
mockGmmResInfo->cpuBltCalled = 0u;
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, getRenderTargetData(_, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, lockRect(_, _, _)).Times(0);
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
@ -659,18 +660,19 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncWhenReleas
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncIntelWhenReleasingThenResourcesAreReleased) {
context->setInteropUserSyncEnabled(false);
surfaceInfo.shared_handle = (HANDLE)1;
mockGmmResInfo->cpuBltCalled = 0u;
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, getRenderTargetData(_, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, lockRect(_, _, _)).Times(0);
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
@ -686,6 +688,7 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncIntelWhenR
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResourcesAreReleased) {
@ -710,15 +713,15 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
GMM_RES_COPY_BLT requestedResCopyBlt = {};
GMM_RES_COPY_BLT &requestedResCopyBlt = mockGmmResInfo->requestedResCopyBlt;
GMM_RES_COPY_BLT expectedResCopyBlt = {};
mockGmmResInfo->cpuBltCalled = 0u;
expectedResCopyBlt.Sys.pData = lockedRect.pBits;
expectedResCopyBlt.Gpu.pData = returnedLockedRes;
expectedResCopyBlt.Sys.RowPitch = lockedRect.Pitch;
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
@ -727,13 +730,13 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
EXPECT_EQ(1, memoryManager->lockResourceCalled);
EXPECT_EQ(1, memoryManager->unlockResourceCalled);
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->cpuBltCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, 0u)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
requestedResCopyBlt = {};
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
@ -742,6 +745,7 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThenResourcesAreReleased) {
@ -765,15 +769,15 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
GMM_RES_COPY_BLT requestedResCopyBlt = {};
GMM_RES_COPY_BLT &requestedResCopyBlt = mockGmmResInfo->requestedResCopyBlt;
GMM_RES_COPY_BLT expectedResCopyBlt = {};
mockGmmResInfo->cpuBltCalled = 0u;
expectedResCopyBlt.Sys.pData = lockedRect.pBits;
expectedResCopyBlt.Gpu.pData = returnedLockedRes;
expectedResCopyBlt.Sys.RowPitch = lockedRect.Pitch;
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
@ -782,13 +786,13 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(1, memoryManager->lockResourceCalled);
EXPECT_EQ(1, memoryManager->unlockResourceCalled);
EXPECT_EQ(1u, mockGmmResInfo->cpuBltCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, 0u)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
requestedResCopyBlt = {};
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
@ -797,6 +801,7 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenResourcesAreReleased) {
@ -822,7 +827,8 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
GMM_RES_COPY_BLT requestedResCopyBlt = {};
GMM_RES_COPY_BLT &requestedResCopyBlt = mockGmmResInfo->requestedResCopyBlt;
mockGmmResInfo->cpuBltCalled = 0u;
GMM_RES_COPY_BLT expectedResCopyBlt = {};
expectedResCopyBlt.Sys.pData = lockedRect.pBits;
expectedResCopyBlt.Gpu.pData = returnedLockedRes;
@ -830,7 +836,6 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
@ -839,13 +844,12 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(1, memoryManager->lockResourceCalled);
EXPECT_EQ(1, memoryManager->unlockResourceCalled);
EXPECT_EQ(1u, mockGmmResInfo->cpuBltCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging, _, 0)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
requestedResCopyBlt = {};
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockGmmResInfo, cpuBlt(_)).Times(1).WillOnce(::testing::Invoke([&](GMM_RES_COPY_BLT *arg) {requestedResCopyBlt = *arg; return 1; }));
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface((IDirect3DSurface9 *)&dummyD3DSurfaceStaging, (IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
@ -854,6 +858,7 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
EXPECT_TRUE(memcmp(&requestedResCopyBlt, &expectedResCopyBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
}
TEST_F(D3D9Tests, givenInvalidClMemObjectPassedOnReleaseListWhenCallIsMadeThenFailureIsReturned) {

4
opencl/test/unit_test/fixtures/d3d_test_fixture.h
View File

@ -87,7 +87,7 @@ class D3DTests : public PlatformFixture, public ::testing::Test {
imgDesc.imageType = ImageType::Image2D;
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
gmm = MockGmm::queryImgParams(pPlatform->peekExecutionEnvironment()->rootDeviceEnvironments[0]->getGmmClientContext(), imgInfo).release();
mockGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(gmm->gmmResourceInfo.get());
mockGmmResInfo = static_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
mockMM->forceGmm = gmm;
}
@ -201,7 +201,7 @@ class D3DTests : public PlatformFixture, public ::testing::Test {
char dummyD3DTexture;
char dummyD3DTextureStaging;
Gmm *gmm = nullptr;
NiceMock<MockGmmResourceInfo> *mockGmmResInfo = nullptr;
MockGmmResourceInfo *mockGmmResInfo = nullptr;
DebugManagerStateRestore dbgRestore;
std::unique_ptr<MockMM> mockMM;

22
opencl/test/unit_test/gmm_helper/gmm_helper_tests.cpp
View File

@ -546,7 +546,7 @@ TEST_P(GmmImgTest, WhenUpdatingImgInfoAndDescThenInformationIsCorrect) {
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
auto queryGmm = MockGmm::queryImgParams(getGmmClientContext(), imgInfo);
auto mockResInfo = new NiceMock<MyMockGmmResourceInfo>(&queryGmm->resourceParams);
auto mockResInfo = new MyMockGmmResourceInfo(&queryGmm->resourceParams);
queryGmm->gmmResourceInfo.reset(mockResInfo);
queryGmm->updateImgInfoAndDesc(updateImgInfo, arrayIndex);
@ -633,9 +633,10 @@ TEST_F(GmmTests, GivenPlaneWhenCopyingResourceBltThenResourceIsCopiedCorrectly)
auto imgInfo = MockGmm::initImgInfo(imgDesc, 0, nullptr);
auto gmm = MockGmm::queryImgParams(getGmmClientContext(), imgInfo);
auto mockResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(gmm->gmmResourceInfo.get());
auto mockResInfo = static_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
GMM_RES_COPY_BLT requestedCpuBlt = {};
GMM_RES_COPY_BLT &requestedCpuBlt = mockResInfo->requestedResCopyBlt;
mockResInfo->cpuBltCalled = 0u;
GMM_RES_COPY_BLT expectedCpuBlt = {};
char sys(0), gpu(0);
uint32_t pitch = 300;
@ -648,47 +649,42 @@ TEST_F(GmmTests, GivenPlaneWhenCopyingResourceBltThenResourceIsCopiedCorrectly)
expectedCpuBlt.Blt.Upload = upload;
expectedCpuBlt.Sys.BufferSize = pitch * height;
auto invokeParamsCopy = [&](GMM_RES_COPY_BLT *resCopyBlt) {
requestedCpuBlt = *resCopyBlt;
return 1;
};
// plane Y
EXPECT_CALL(*mockResInfo, cpuBlt(_)).Times(1).WillOnce(Invoke(invokeParamsCopy));
auto retVal = gmm->resourceCopyBlt(&sys, &gpu, pitch, height, upload, ImagePlane::PLANE_Y);
EXPECT_EQ(1u, retVal);
EXPECT_TRUE(memcmp(&expectedCpuBlt, &requestedCpuBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(1u, mockResInfo->cpuBltCalled);
// no-plane
EXPECT_CALL(*mockResInfo, cpuBlt(_)).Times(1).WillOnce(Invoke(invokeParamsCopy));
retVal = gmm->resourceCopyBlt(&sys, &gpu, pitch, height, upload, ImagePlane::NO_PLANE);
EXPECT_EQ(1u, retVal);
EXPECT_TRUE(memcmp(&expectedCpuBlt, &requestedCpuBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(2u, mockResInfo->cpuBltCalled);
//plane UV
expectedCpuBlt.Sys.pData = ptrOffset(&sys, height * pitch * 2u);
EXPECT_CALL(*mockResInfo, cpuBlt(_)).Times(1).WillOnce(Invoke(invokeParamsCopy));
retVal = gmm->resourceCopyBlt(&sys, &gpu, pitch, height, upload, ImagePlane::PLANE_UV);
EXPECT_EQ(1u, retVal);
EXPECT_TRUE(memcmp(&expectedCpuBlt, &requestedCpuBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(3u, mockResInfo->cpuBltCalled);
//plane V
expectedCpuBlt.Sys.pData = ptrOffset(&sys, height * pitch * 2u);
expectedCpuBlt.Sys.RowPitch = pitch / 2;
expectedCpuBlt.Sys.BufferSize = expectedCpuBlt.Sys.RowPitch * height;
EXPECT_CALL(*mockResInfo, cpuBlt(_)).Times(1).WillOnce(Invoke(invokeParamsCopy));
retVal = gmm->resourceCopyBlt(&sys, &gpu, pitch, height, upload, ImagePlane::PLANE_V);
EXPECT_EQ(1u, retVal);
EXPECT_TRUE(memcmp(&expectedCpuBlt, &requestedCpuBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(4u, mockResInfo->cpuBltCalled);
//plane U
expectedCpuBlt.Sys.pData = ptrOffset(&sys, height * pitch * 2u + height * pitch / 2u);
expectedCpuBlt.Sys.RowPitch = pitch / 2;
expectedCpuBlt.Sys.BufferSize = expectedCpuBlt.Sys.RowPitch * height;
EXPECT_CALL(*mockResInfo, cpuBlt(_)).Times(1).WillOnce(Invoke(invokeParamsCopy));
retVal = gmm->resourceCopyBlt(&sys, &gpu, pitch, height, upload, ImagePlane::PLANE_U);
EXPECT_EQ(1u, retVal);
EXPECT_TRUE(memcmp(&expectedCpuBlt, &requestedCpuBlt, sizeof(GMM_RES_COPY_BLT)) == 0);
EXPECT_EQ(5u, mockResInfo->cpuBltCalled);
}
TEST_F(GmmTests, givenAllValidFlagsWhenAskedForUnifiedAuxTranslationCapabilityThenReturnTrue) {

12
opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
View File

@ -684,7 +684,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
auto mockMcsGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
auto mockMcsGmmResInfo = static_cast<MockGmmResourceInfo *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
mockMcsGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_TRUE(mcsAlloc->getDefaultGmm()->unifiedAuxTranslationCapable());
@ -716,7 +716,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
auto mockMcsGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
auto mockMcsGmmResInfo = static_cast<MockGmmResourceInfo *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
mockMcsGmmResInfo->setUnifiedAuxTranslationCapable();
mockMcsGmmResInfo->setMultisampleControlSurface();
EXPECT_TRUE(mcsAlloc->getDefaultGmm()->unifiedAuxTranslationCapable());
@ -745,7 +745,7 @@ HWTEST_F(ImageSetArgTest, givenMcsAllocationWhenSetArgIsCalledWithUnifiedAuxCapa
image->setMcsAllocation(mcsAlloc);
cl_mem memObj = image.get();
auto mockMcsGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
auto mockMcsGmmResInfo = static_cast<MockGmmResourceInfo *>(mcsAlloc->getDefaultGmm()->gmmResourceInfo.get());
mockMcsGmmResInfo->setUnifiedAuxTranslationCapable();
mockMcsGmmResInfo->setMultisampleControlSurface();
@ -896,10 +896,9 @@ HWTEST_F(ImageSetArgTest, givenNonRenderCompressedResourceWhenSettingImgArgThenD
auto surfaceState = FamilyType::cmdInitRenderSurfaceState;
auto gmm = srcAllocation->getDefaultGmm();
auto mockGmmResInfo = reinterpret_cast<NiceMock<MockGmmResourceInfo> *>(gmm->gmmResourceInfo.get());
auto mockGmmResInfo = static_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
gmm->isCompressionEnabled = false;
EXPECT_CALL(*mockGmmResInfo, getUnifiedAuxSurfaceOffset(_)).Times(0);
mockGmmResInfo->getUnifiedAuxSurfaceOffsetCalled = 0u;
EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceQpitch());
EXPECT_EQ(1u, surfaceState.getAuxiliarySurfacePitch());
@ -910,6 +909,7 @@ HWTEST_F(ImageSetArgTest, givenNonRenderCompressedResourceWhenSettingImgArgThenD
EXPECT_EQ(1u, surfaceState.getAuxiliarySurfacePitch());
EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceQpitch());
EXPECT_EQ(0u, surfaceState.getAuxiliarySurfaceBaseAddress());
EXPECT_EQ(0u, mockGmmResInfo->getUnifiedAuxSurfaceOffsetCalled);
}
/* cl_intel_media_block_io */

2
opencl/test/unit_test/mem_obj/nv12_image_tests.cpp
View File

@ -34,7 +34,7 @@ class Nv12ImageTest : public testing::Test {
GMM_REQ_OFFSET_INFO reqOffsetInfo = {};
SurfaceOffsets requestedOffsets = {0};
auto mockResInfo = reinterpret_cast<::testing::NiceMock<MockGmmResourceInfo> *>(image->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo.get());
auto mockResInfo = static_cast<MockGmmResourceInfo *>(image->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getDefaultGmm()->gmmResourceInfo.get());
mockResInfo->getOffset(reqOffsetInfo);
if (image->getImageDesc().mem_object) {

2
opencl/test/unit_test/mocks/mock_gmm_resource_info_ocl.cpp
View File

@ -9,6 +9,8 @@
#include "opencl/source/helpers/surface_formats.h"
#include "gtest/gtest.h"
namespace NEO {
void MockGmmResourceInfo::setSurfaceFormat() {

2
opencl/test/unit_test/sharings/gl/windows/gl_create_from_texture_tests.cpp
View File

@ -255,7 +255,7 @@ TEST_P(CreateFromGlTextureTestsWithParams, givenZeroRowPitchFromGmmWhenCreatingT
updateImgInfoAndForceGmm();
auto mockResInfo = reinterpret_cast<::testing::NiceMock<MockGmmResourceInfo> *>(gmm->gmmResourceInfo.get());
auto mockResInfo = static_cast<MockGmmResourceInfo *>(gmm->gmmResourceInfo.get());
mockResInfo->overrideReturnedRenderPitch(0u);
auto alignedWidth = alignUp(imgDesc.imageWidth, gmm->gmmResourceInfo->getHAlign());

2
opencl/test/unit_test/sharings/gl/windows/gl_texture_tests.cpp
View File

@ -75,7 +75,7 @@ class GlSharingTextureTests : public ::testing::Test {
void setUnifiedAuxSurf() {
tempMM->useForcedGmm = true;
auto mockGmmResInfo = reinterpret_cast<::testing::NiceMock<MockGmmResourceInfo> *>(tempMM->forceGmm->gmmResourceInfo.get());
auto mockGmmResInfo = static_cast<MockGmmResourceInfo *>(tempMM->forceGmm->gmmResourceInfo.get());
mockGmmResInfo->setUnifiedAuxTranslationCapable();
}

16
shared/test/common/mocks/mock_gmm_resource_info.h
View File

@ -8,8 +8,7 @@
#pragma once
#include "shared/source/gmm_helper/resource_info.h"
#include "shared/source/helpers/surface_format_info.h"
#include "gmock/gmock.h"
#include "shared/test/common/test_macros/mock_method_macros.h"
namespace NEO {
struct SurfaceFormatInfo;
@ -68,11 +67,17 @@ class MockGmmResourceInfo : public GmmResourceInfo {
GMM_STATUS getOffset(GMM_REQ_OFFSET_INFO &reqOffsetInfo) override;
MOCK_METHOD(uint8_t, cpuBlt, (GMM_RES_COPY_BLT * resCopyBlt), (override));
uint8_t cpuBlt(GMM_RES_COPY_BLT *resCopyBlt) override {
cpuBltCalled++;
if (resCopyBlt) {
requestedResCopyBlt = *resCopyBlt;
}
return cpuBltResult;
};
void *getSystemMemPointer() override { return (void *)mockResourceCreateParams.pExistingSysMem; }
MOCK_METHOD(uint64_t, getUnifiedAuxSurfaceOffset, (GMM_UNIFIED_AUX_TYPE auxType), (override));
ADDMETHOD_NOBASE(getUnifiedAuxSurfaceOffset, uint64_t, 0u, (GMM_UNIFIED_AUX_TYPE auxType));
bool is64KBPageSuitable() const override { return is64KBPageSuitableValue; }
@ -103,6 +108,9 @@ class MockGmmResourceInfo : public GmmResourceInfo {
uint32_t arrayIndexPassedToGetOffset = 0;
SurfaceFormatInfo tempSurface{};
bool is64KBPageSuitableValue = true;
GMM_RES_COPY_BLT requestedResCopyBlt = {};
uint32_t cpuBltCalled = 0u;
uint8_t cpuBltResult = 1u;
protected:
MockGmmResourceInfo();

6
shared/test/common/mocks/mock_gmm_resource_info_common.cpp
View File

@ -8,18 +8,16 @@
#include "shared/source/helpers/aligned_memory.h"
#include "shared/test/common/mocks/mock_gmm_resource_info.h"
using namespace ::testing;
namespace NEO {
GmmResourceInfo *GmmResourceInfo::create(GmmClientContext *clientContext, GMM_RESCREATE_PARAMS *resourceCreateParams) {
if (resourceCreateParams->Type == GMM_RESOURCE_TYPE::RESOURCE_INVALID) {
return nullptr;
}
return new ::testing::NiceMock<MockGmmResourceInfo>(resourceCreateParams);
return new MockGmmResourceInfo(resourceCreateParams);
}
GmmResourceInfo *GmmResourceInfo::create(GmmClientContext *clientContext, GMM_RESOURCE_INFO *inputGmmResourceInfo) {
return new ::testing::NiceMock<MockGmmResourceInfo>(inputGmmResourceInfo);
return new MockGmmResourceInfo(inputGmmResourceInfo);
}
MockGmmResourceInfo::MockGmmResourceInfo(GMM_RESCREATE_PARAMS *resourceCreateParams) {