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 MockD3DSharingFunctions

Browse Source 
Related-To: NEO-4914
Signed-off-by: Fabian Zwolinski <fabian.zwolinski@intel.com>
This commit is contained in:
Fabian Zwolinski
2022-02-11 15:25:20 +00:00
committed by Compute-Runtime-Automation
parent 83025da96f
commit 63ae26715e
7 changed files with 1042 additions and 566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
opencl/test/unit_test/d3d_sharing/cl_dx_sharing_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -17,7 +17,6 @@
#include "opencl/test/unit_test/mocks/mock_buffer.h"
#include "opencl/test/unit_test/mocks/mock_d3d_objects.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
static const DXGI_FORMAT DXGIformats[] = {
@ -146,7 +145,7 @@ struct clIntelSharingFormatQueryDX1X : public PlatformFixture, public ::testing:
std::vector<DXGI_FORMAT> retrievedFormats;
ArrayRef<const DXGI_FORMAT> availableFormats;
NiceMock<MockD3DSharingFunctions<T>> *mockSharingFcns;
MockD3DSharingFunctions<T> *mockSharingFcns;
MockContext *context;
cl_uint numImageFormats;
cl_int retVal;
@ -155,11 +154,11 @@ struct clIntelSharingFormatQueryDX1X : public PlatformFixture, public ::testing:
void SetUp() override {
PlatformFixture::SetUp();
context = new MockContext(pPlatform->getClDevice(0));
mockSharingFcns = new NiceMock<MockD3DSharingFunctions<T>>();
mockSharingFcns = new MockD3DSharingFunctions<T>();
context->setSharingFunctions(mockSharingFcns);
auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool { *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D; return true; };
ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
mockSharingFcns->checkFormatSupportSetParam1 = true;
mockSharingFcns->checkFormatSupportParamsSet.pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
availableFormats = ArrayRef<const DXGI_FORMAT>(DXGIformats);
retrievedFormats.assign(availableFormats.size(), DXGI_FORMAT_UNKNOWN);
@ -273,8 +272,6 @@ TEST_F(clIntelSharingFormatQueryDX11, givenValidParametersWhenRequestedDX11Textu
}
TEST_F(clIntelSharingFormatQueryDX11, givenValidParametersWhenRequestingDX11TextureFormatsForPlane1ThenPlanarFormatsAreReturned) {
ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
retVal = clGetSupportedD3D11TextureFormatsINTEL(context, CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D, 1,
static_cast<cl_uint>(retrievedFormats.size()),
&retrievedFormats[0], &numImageFormats);

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

@ -96,12 +96,12 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test {
context->preferD3dSharedResources = true;
context->memoryManager = memoryManager.get();
mockSharingFcns = new NiceMock<MockD3DSharingFunctions<D3D9>>();
mockSharingFcns = new MockD3DSharingFunctions<D3D9>();
context->setSharingFunctions(mockSharingFcns);
cmdQ = new MockCommandQueue(context, context->getDevice(0), 0, false);
DebugManager.injectFcn = &mockSharingFcns->mockGetDxgiDesc;
surfaceInfo.resource = (IDirect3DSurface9 *)&dummyD3DSurface;
surfaceInfo.resource = reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface);
mockSharingFcns->mockTexture2dDesc.Format = D3DFMT_R32F;
mockSharingFcns->mockTexture2dDesc.Height = 10;
@ -119,7 +119,7 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test {
PlatformFixture::TearDown();
}
NiceMock<MockD3DSharingFunctions<D3D9>> *mockSharingFcns;
MockD3DSharingFunctions<D3D9> *mockSharingFcns;
MockContext *context;
MockCommandQueue *cmdQ;
DebugManagerStateRestore dbgRestore;
@ -153,7 +153,7 @@ TEST_F(D3D9Tests, givenD3DDeviceParamWhenContextCreationThenSetProperValues) {
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, ctx.get());
EXPECT_NE(nullptr, ctx->getSharing<D3DSharingFunctions<D3D9>>());
EXPECT_TRUE((D3DDevice *)&expectedDevice == ctx->getSharing<D3DSharingFunctions<D3D9>>()->getDevice());
EXPECT_TRUE(reinterpret_cast<D3DDevice *>(&expectedDevice) == ctx->getSharing<D3DSharingFunctions<D3D9>>()->getDevice());
}
}
@ -179,8 +179,8 @@ TEST_F(D3D9Tests, WhenCreatingSurfaceThenImagePropertiesAreSetCorrectly) {
ImagePlane imagePlane = ImagePlane::NO_PLANE;
D3DSurface::findImgFormat(mockSharingFcns->mockTexture2dDesc.Format, expectedImgFormat, 0, imagePlane);
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto memObj = clCreateFromDX9MediaSurfaceKHR(context, CL_MEM_READ_WRITE, 0, &surfaceInfo, 0, &retVal);
ASSERT_NE(nullptr, memObj);
@ -199,6 +199,11 @@ TEST_F(D3D9Tests, WhenCreatingSurfaceThenImagePropertiesAreSetCorrectly) {
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height, image->getImageDesc().image_height);
clReleaseMemObject(memObj);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST(D3D9SimpleTests, givenWrongFormatWhenFindIsCalledThenErrorIsReturned) {
@ -214,8 +219,8 @@ TEST_F(D3D9Tests, WhenCreatingSurfaceIntelThenImagePropertiesAreSetCorrectly) {
ImagePlane imagePlane = ImagePlane::NO_PLANE;
D3DSurface::findImgFormat(mockSharingFcns->mockTexture2dDesc.Format, expectedImgFormat, 0, imagePlane);
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto memObj = clCreateFromDX9MediaSurfaceINTEL(context, CL_MEM_READ_WRITE, surfaceInfo.resource, surfaceInfo.shared_handle, 0, &retVal);
ASSERT_NE(nullptr, memObj);
@ -233,26 +238,35 @@ TEST_F(D3D9Tests, WhenCreatingSurfaceIntelThenImagePropertiesAreSetCorrectly) {
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height, image->getImageDesc().image_height);
clReleaseMemObject(memObj);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, givenD3DHandleWhenCreatingSharedSurfaceThenAllocationTypeImageIsSet) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = reinterpret_cast<HANDLE>(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 2, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
auto graphicsAllocation = sharedImg->getGraphicsAllocation(context->getDevice(0)->getRootDeviceIndex());
ASSERT_NE(nullptr, graphicsAllocation);
EXPECT_EQ(AllocationType::SHARED_IMAGE, graphicsAllocation->getAllocationType());
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenUPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)1;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 2, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -260,13 +274,16 @@ TEST_F(D3D9Tests, givenUPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch()) / 2;
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenVPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)1;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -274,13 +291,16 @@ TEST_F(D3D9Tests, givenVPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch()) / 2;
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenUVPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)1;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -288,13 +308,16 @@ TEST_F(D3D9Tests, givenUVPlaneWhenCreateSurfaceThenChangeWidthHeightAndPitch) {
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenYPlaneWhenCreateSurfaceThenDontChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)1;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -302,13 +325,16 @@ TEST_F(D3D9Tests, givenYPlaneWhenCreateSurfaceThenDontChangeWidthHeightAndPitch)
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenUPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 2, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -316,13 +342,16 @@ TEST_F(D3D9Tests, givenUPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAndP
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenVPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -330,13 +359,16 @@ TEST_F(D3D9Tests, givenVPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAndP
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenUVPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -344,13 +376,16 @@ TEST_F(D3D9Tests, givenUVPlaneWhenCreateNonSharedSurfaceThenChangeWidthHeightAnd
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height / 2, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenYPlaneWhenCreateNonSharedSurfaceThenDontChangeWidthHeightAndPitch) {
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -358,13 +393,17 @@ TEST_F(D3D9Tests, givenYPlaneWhenCreateNonSharedSurfaceThenDontChangeWidthHeight
EXPECT_EQ(mockSharingFcns->mockTexture2dDesc.Height, sharedImg->getImageDesc().image_height);
size_t expectedRowPitch = static_cast<size_t>(mockGmmResInfo->getRenderPitch());
EXPECT_EQ(expectedRowPitch, sharedImg->getImageDesc().image_row_pitch);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenNV12FormatAndInvalidPlaneWhenSurfaceIsCreatedThenReturnError) {
cl_int retVal = CL_SUCCESS;
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto img = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 2, &retVal);
EXPECT_EQ(nullptr, img);
@ -375,7 +414,9 @@ TEST_F(D3D9Tests, givenYV12FormatAndInvalidPlaneWhenSurfaceIsCreatedThenReturnEr
cl_int retVal = CL_SUCCESS;
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2');
surfaceInfo.shared_handle = (HANDLE)0;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto img = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 3, &retVal);
EXPECT_EQ(nullptr, img);
@ -386,7 +427,9 @@ TEST_F(D3D9Tests, givenNonPlaneFormatAndNonZeroPlaneWhenSurfaceIsCreatedThenRetu
cl_int retVal = CL_SUCCESS;
mockSharingFcns->mockTexture2dDesc.Format = D3DFORMAT::D3DFMT_A16B16G16R16;
surfaceInfo.shared_handle = (HANDLE)0;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto img = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, &retVal);
EXPECT_EQ(nullptr, img);
@ -403,7 +446,9 @@ TEST_F(D3D9Tests, givenNullResourceWhenSurfaceIsCreatedThenReturnError) {
TEST_F(D3D9Tests, givenNonDefaultPoolWhenSurfaceIsCreatedThenReturnError) {
cl_int retVal = CL_SUCCESS;
mockSharingFcns->mockTexture2dDesc.Pool = D3DPOOL_SYSTEMMEM;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto img = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 1, &retVal);
EXPECT_EQ(nullptr, img);
@ -412,8 +457,10 @@ TEST_F(D3D9Tests, givenNonDefaultPoolWhenSurfaceIsCreatedThenReturnError) {
TEST_F(D3D9Tests, givenAlreadyUsedSurfaceWhenSurfaceIsCreatedThenReturnError) {
cl_int retVal = CL_SUCCESS;
surfaceInfo.resource = (IDirect3DSurface9 *)1;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
surfaceInfo.resource = reinterpret_cast<IDirect3DSurface9 *>(1);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
std::unique_ptr<Image> img(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, &retVal));
EXPECT_NE(nullptr, img.get());
@ -427,7 +474,9 @@ TEST_F(D3D9Tests, givenNotSupportedFormatWhenSurfaceIsCreatedThenReturnError) {
cl_int retVal = CL_SUCCESS;
mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('I', '4', '2', '0');
surfaceInfo.shared_handle = (HANDLE)0;
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto img = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, &retVal);
EXPECT_EQ(nullptr, img);
@ -442,7 +491,8 @@ TEST_F(D3D9Tests, GivenMediaSurfaceInfoKhrWhenGetMemObjInfoThenCorrectInfoIsRetu
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -452,6 +502,8 @@ TEST_F(D3D9Tests, GivenMediaSurfaceInfoKhrWhenGetMemObjInfoThenCorrectInfoIsRetu
EXPECT_EQ(getSurfaceInfo.resource, surfaceInfo.resource);
EXPECT_EQ(getSurfaceInfo.shared_handle, surfaceInfo.shared_handle);
EXPECT_EQ(sizeof(cl_dx9_surface_info_khr), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, GivenResourceIntelWhenGetMemObjInfoThenCorrectInfoIsReturned) {
@ -462,7 +514,8 @@ TEST_F(D3D9Tests, GivenResourceIntelWhenGetMemObjInfoThenCorrectInfoIsReturned)
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -472,6 +525,8 @@ TEST_F(D3D9Tests, GivenResourceIntelWhenGetMemObjInfoThenCorrectInfoIsReturned)
sharedImg->getMemObjectInfo(CL_MEM_DX9_RESOURCE_INTEL, sizeof(IDirect3DSurface9 *), &getSurfaceInfo.resource, &retSize);
EXPECT_EQ(getSurfaceInfo.resource, surfaceInfo.resource);
EXPECT_EQ(sizeof(IDirect3DSurface9 *), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, GivenSharedHandleIntelWhenGetMemObjInfoThenCorrectInfoIsReturned) {
@ -482,7 +537,8 @@ TEST_F(D3D9Tests, GivenSharedHandleIntelWhenGetMemObjInfoThenCorrectInfoIsReturn
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -491,6 +547,8 @@ TEST_F(D3D9Tests, GivenSharedHandleIntelWhenGetMemObjInfoThenCorrectInfoIsReturn
sharedImg->getMemObjectInfo(CL_MEM_DX9_SHARED_HANDLE_INTEL, sizeof(IDirect3DSurface9 *), &getSurfaceInfo.shared_handle, &retSize);
EXPECT_EQ(getSurfaceInfo.shared_handle, surfaceInfo.shared_handle);
EXPECT_EQ(sizeof(IDirect3DSurface9 *), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, GivenMediaAdapterTypeKhrWhenGetMemObjInfoThenCorrectInfoIsReturned) {
@ -501,7 +559,8 @@ TEST_F(D3D9Tests, GivenMediaAdapterTypeKhrWhenGetMemObjInfoThenCorrectInfoIsRetu
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -510,6 +569,8 @@ TEST_F(D3D9Tests, GivenMediaAdapterTypeKhrWhenGetMemObjInfoThenCorrectInfoIsRetu
sharedImg->getMemObjectInfo(CL_MEM_DX9_MEDIA_ADAPTER_TYPE_KHR, sizeof(cl_dx9_media_adapter_type_khr), &adapterType, &retSize);
EXPECT_EQ(expectedAdapterType, adapterType);
EXPECT_EQ(sizeof(cl_dx9_media_adapter_type_khr), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, GivenMediaPlaneKhrWhenGetMemObjInfoThenCorrectInfoIsReturned) {
@ -520,7 +581,8 @@ TEST_F(D3D9Tests, GivenMediaPlaneKhrWhenGetMemObjInfoThenCorrectInfoIsReturned)
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -529,6 +591,8 @@ TEST_F(D3D9Tests, GivenMediaPlaneKhrWhenGetMemObjInfoThenCorrectInfoIsReturned)
sharedImg->getImageInfo(CL_IMAGE_DX9_MEDIA_PLANE_KHR, sizeof(cl_uint), &plane, &retSize);
EXPECT_EQ(expectedPlane, plane);
EXPECT_EQ(sizeof(cl_uint), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, GivenPlaneIntelWhenGetMemObjInfoThenCorrectInfoIsReturned) {
@ -539,7 +603,8 @@ TEST_F(D3D9Tests, GivenPlaneIntelWhenGetMemObjInfoThenCorrectInfoIsReturned) {
surfaceInfo.shared_handle = (HANDLE)1;
size_t retSize = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE,
expectedAdapterType, expectedPlane, nullptr));
@ -548,15 +613,15 @@ TEST_F(D3D9Tests, GivenPlaneIntelWhenGetMemObjInfoThenCorrectInfoIsReturned) {
sharedImg->getImageInfo(CL_IMAGE_DX9_PLANE_INTEL, sizeof(cl_uint), &plane, &retSize);
EXPECT_EQ(expectedPlane, plane);
EXPECT_EQ(sizeof(cl_uint), retSize);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenSharedHandleWhenCreateThenDontCreateStagingSurface) {
surfaceInfo.shared_handle = (HANDLE)1;
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, createTexture2d(_, _, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, addRef(_)).Times(1);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -566,15 +631,18 @@ TEST_F(D3D9Tests, givenSharedHandleWhenCreateThenDontCreateStagingSurface) {
auto surface = static_cast<D3DSurface *>(sharedImg->getSharingHandler().get());
EXPECT_TRUE(surface->isSharedResource());
EXPECT_EQ(nullptr, surface->getResourceStaging());
EXPECT_EQ(0u, mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->addRefCalled);
}
TEST_F(D3D9Tests, givenZeroSharedHandleAndLockableFlagWhenCreateThenDontCreateStagingSurface) {
surfaceInfo.shared_handle = (HANDLE)0;
mockSharingFcns->mockTexture2dDesc.Usage = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, createTexture2d(_, _, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, addRef(_)).Times(1);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -584,15 +652,21 @@ TEST_F(D3D9Tests, givenZeroSharedHandleAndLockableFlagWhenCreateThenDontCreateSt
EXPECT_FALSE(surface->isSharedResource());
EXPECT_EQ(nullptr, surface->getResourceStaging());
EXPECT_TRUE(surface->lockable);
EXPECT_EQ(0u, mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->addRefCalled);
}
TEST_F(D3D9Tests, givenZeroSharedHandleAndNonLockableFlagWhenCreateThenCreateStagingSurface) {
surfaceInfo.shared_handle = (HANDLE)0;
mockSharingFcns->mockTexture2dDesc.Usage = D3DResourceFlags::USAGE_RENDERTARGET;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*mockSharingFcns, createTexture2d(_, _, _)).Times(1).WillOnce(SetArgPointee<0>((D3DTexture2d *)&dummyD3DSurfaceStaging));
EXPECT_CALL(*mockSharingFcns, addRef(_)).Times(1);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
mockSharingFcns->createTexture2dSetParams = true;
mockSharingFcns->createTexture2dParamsSet.texture = (D3DTexture2d *)&dummyD3DSurfaceStaging;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -602,6 +676,10 @@ TEST_F(D3D9Tests, givenZeroSharedHandleAndNonLockableFlagWhenCreateThenCreateSta
EXPECT_FALSE(surface->isSharedResource());
EXPECT_NE(nullptr, surface->getResourceStaging());
EXPECT_FALSE(surface->lockable);
EXPECT_EQ(1u, mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->addRefCalled);
}
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndEnabledInteropUserSyncWhenReleasingThenResourcesAreReleased) {
@ -609,14 +687,8 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndEnabledInteropUserSyncWhenReleasi
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(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg);
@ -632,6 +704,15 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndEnabledInteropUserSyncWhenReleasi
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(0u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(0u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(0u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncWhenReleasingThenResourcesAreReleased) {
@ -639,14 +720,9 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncWhenReleas
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(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -661,6 +737,15 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncWhenReleas
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(0u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(0u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncIntelWhenReleasingThenResourcesAreReleased) {
@ -668,14 +753,9 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncIntelWhenR
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(*mockSharingFcns, unlockRect(_)).Times(0);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -689,6 +769,15 @@ TEST_F(D3D9Tests, GivenSharedResourceSurfaceAndDisabledInteropUserSyncIntelWhenR
EXPECT_EQ(0, memoryManager->lockResourceCalled);
EXPECT_EQ(0, memoryManager->unlockResourceCalled);
EXPECT_EQ(0u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(0u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(0u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResourcesAreReleased) {
@ -696,9 +785,8 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
mockSharingFcns->mockTexture2dDesc.Usage = 0;
D3DLOCKED_RECT lockedRect = {10u, (void *)100};
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -708,8 +796,9 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
auto imgHeight = static_cast<ULONG>(sharedImg->getImageDesc().image_height);
void *returnedLockedRes = (void *)100;
EXPECT_CALL(*mockSharingFcns, getRenderTargetData(_, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, D3DLOCK_READONLY)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectSetParams = true;
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
@ -722,23 +811,20 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
auto retVal = clEnqueueAcquireDX9MediaSurfacesKHR(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
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_EQ(1u, mockSharingFcns->lockRectCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, 0u)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
requestedResCopyBlt = {};
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
EXPECT_EQ(1u, mockSharingFcns->unlockRectCalled);
retVal = clEnqueueReleaseDX9MediaSurfacesKHR(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -746,6 +832,23 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableWhenReleasingThenResou
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(2u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(2u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(0u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[0].d3dResource);
EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[1].d3dResource);
EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[0].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[1].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThenResourcesAreReleased) {
@ -753,9 +856,8 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
mockSharingFcns->mockTexture2dDesc.Usage = 0;
D3DLOCKED_RECT lockedRect = {10u, (void *)100};
::testing::InSequence is;
EXPECT_CALL(*mockSharingFcns, updateDevice((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -764,8 +866,9 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
auto imgHeight = static_cast<ULONG>(sharedImg->getImageDesc().image_height);
void *returnedLockedRes = (void *)100;
EXPECT_CALL(*mockSharingFcns, getRenderTargetData(_, _)).Times(0);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, D3DLOCK_READONLY)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectSetParams = true;
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
@ -778,23 +881,20 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
auto retVal = clEnqueueAcquireDX9ObjectsINTEL(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
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_EQ(1u, mockSharingFcns->lockRectCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurface, _, 0u)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
requestedResCopyBlt = {};
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface(_, _)).Times(0);
EXPECT_EQ(1u, mockSharingFcns->unlockRectCalled);
retVal = clEnqueueReleaseDX9ObjectsINTEL(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -802,6 +902,23 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndLockableIntelWhenReleasingThen
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(2u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(2u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(0u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(0u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[0].d3dResource);
EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[1].d3dResource);
EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[0].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[1].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenResourcesAreReleased) {
@ -809,10 +926,11 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
mockSharingFcns->mockTexture2dDesc.Usage = D3DResourceFlags::USAGE_RENDERTARGET;
D3DLOCKED_RECT lockedRect = {10u, (void *)100};
::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, createTexture2d(_, _, _)).Times(1).WillOnce(SetArgPointee<0>((D3DTexture2d *)&dummyD3DSurfaceStaging));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
mockSharingFcns->createTexture2dSetParams = true;
mockSharingFcns->createTexture2dParamsSet.texture = (D3DTexture2d *)&dummyD3DSurfaceStaging;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -822,8 +940,9 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
auto imgHeight = static_cast<ULONG>(sharedImg->getImageDesc().image_height);
void *returnedLockedRes = (void *)100;
EXPECT_CALL(*mockSharingFcns, getRenderTargetData((IDirect3DSurface9 *)&dummyD3DSurface, (IDirect3DSurface9 *)&dummyD3DSurfaceStaging)).Times(1);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging, _, D3DLOCK_READONLY)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectSetParams = true;
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
memoryManager->lockResourceReturnValue = returnedLockedRes;
memoryManager->expectedLockingAllocation = graphicsAllocation;
@ -836,22 +955,19 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
expectedResCopyBlt.Blt.Upload = 1;
expectedResCopyBlt.Sys.BufferSize = lockedRect.Pitch * imgHeight;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging)).Times(1);
EXPECT_CALL(*mockSharingFcns, flushAndWait(_)).Times(1);
auto retVal = clEnqueueAcquireDX9MediaSurfacesKHR(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
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_EQ(1u, mockSharingFcns->lockRectCalled);
EXPECT_CALL(*mockSharingFcns, lockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging, _, 0)).Times(1).WillOnce(SetArgPointee<1>(lockedRect));
mockSharingFcns->lockRectParamsSet.lockedRect = lockedRect;
expectedResCopyBlt.Blt.Upload = 0;
EXPECT_CALL(*mockSharingFcns, unlockRect((IDirect3DSurface9 *)&dummyD3DSurfaceStaging)).Times(1);
EXPECT_CALL(*mockSharingFcns, updateSurface((IDirect3DSurface9 *)&dummyD3DSurfaceStaging, (IDirect3DSurface9 *)&dummyD3DSurface)).Times(1);
EXPECT_EQ(1u, mockSharingFcns->unlockRectCalled);
retVal = clEnqueueReleaseDX9MediaSurfacesKHR(cmdQ, 1, &clMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -859,6 +975,30 @@ TEST_F(D3D9Tests, GivenNonSharedResourceSurfaceAndNonLockableWhenReleasingThenRe
EXPECT_EQ(2, memoryManager->lockResourceCalled);
EXPECT_EQ(2, memoryManager->unlockResourceCalled);
EXPECT_EQ(2u, mockGmmResInfo->cpuBltCalled);
EXPECT_EQ(1u, mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(2u, mockSharingFcns->lockRectCalled);
EXPECT_EQ(2u, mockSharingFcns->unlockRectCalled);
EXPECT_EQ(1u, mockSharingFcns->getRenderTargetDataCalled);
EXPECT_EQ(1u, mockSharingFcns->updateSurfaceCalled);
EXPECT_EQ(1u, mockSharingFcns->updateDeviceCalled);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->lockRectParamsPassed[0].d3dResource);
EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->lockRectParamsPassed[1].d3dResource);
EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->unlockRectParamsPassed[0].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->unlockRectParamsPassed[1].d3dResource);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->getRenderTargetDataParamsPassed[0].renderTarget);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->getRenderTargetDataParamsPassed[0].dstSurface);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurfaceStaging), mockSharingFcns->updateSurfaceParamsPassed[0].renderTarget);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateSurfaceParamsPassed[0].dstSurface);
EXPECT_EQ(reinterpret_cast<IDirect3DSurface9 *>(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource);
}
TEST_F(D3D9Tests, givenInvalidClMemObjectPassedOnReleaseListWhenCallIsMadeThenFailureIsReturned) {
@ -868,9 +1008,10 @@ TEST_F(D3D9Tests, givenInvalidClMemObjectPassedOnReleaseListWhenCallIsMadeThenFa
}
TEST_F(D3D9Tests, givenResourcesCreatedFromDifferentDevicesWhenAcquireReleaseCalledThenUpdateDevice) {
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto createdResourceDevice = (D3DDevice *)123;
auto createdResourceDevice = reinterpret_cast<D3DDevice *>(123);
mockSharingFcns->setDevice(createdResourceDevice); // create call will pick this device
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, 0, nullptr));
ASSERT_NE(nullptr, sharedImg.get());
@ -883,6 +1024,8 @@ TEST_F(D3D9Tests, givenResourcesCreatedFromDifferentDevicesWhenAcquireReleaseCal
mockSharingFcns->setDevice(nullptr); // force device change
sharedImg->getSharingHandler()->release(sharedImg.get(), context->getDevice(0)->getRootDeviceIndex());
EXPECT_EQ(createdResourceDevice, mockSharingFcns->getDevice());
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, givenNullD3dDeviceWhenContextIsCreatedThenReturnErrorOnSurfaceCreation) {
@ -944,7 +1087,8 @@ TEST_F(D3D9Tests, givenTheSameResourceAndPlaneWhenSurfaceIsCreatedThenReturnErro
cl_int retVal = CL_SUCCESS;
cl_uint plane = 0;
EXPECT_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
auto sharedImg = std::unique_ptr<Image>(D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, plane, &retVal));
EXPECT_NE(nullptr, sharedImg.get());
@ -952,6 +1096,8 @@ TEST_F(D3D9Tests, givenTheSameResourceAndPlaneWhenSurfaceIsCreatedThenReturnErro
auto sharedImg2 = D3DSurface::create(context, &surfaceInfo, CL_MEM_READ_WRITE, 0, plane, &retVal);
EXPECT_EQ(nullptr, sharedImg2);
EXPECT_EQ(CL_INVALID_DX9_RESOURCE_INTEL, retVal);
EXPECT_EQ(1u, mockSharingFcns->getTexture2dDescCalled);
}
TEST_F(D3D9Tests, WhenFillingBufferDescThenBufferContentsAreCorrect) {
@ -1161,7 +1307,7 @@ TEST_F(D3D9MultiRootDeviceTest, givenD3DHandleIsNullWhenCreatingSharedSurfaceAnd
auto memoryManager = std::make_unique<MockMM>(*device1->executionEnvironment);
memoryManager->forceGmm = gmm;
auto mockSharingFcns = new NiceMock<MockD3DSharingFunctions<D3DTypesHelper::D3D9>>();
auto mockSharingFcns = new MockD3DSharingFunctions<D3DTypesHelper::D3D9>();
mockSharingFcns->mockTexture2dDesc.Format = D3DFMT_R32F;
mockSharingFcns->mockTexture2dDesc.Height = 10;
mockSharingFcns->mockTexture2dDesc.Width = 10;
@ -1169,7 +1315,8 @@ TEST_F(D3D9MultiRootDeviceTest, givenD3DHandleIsNullWhenCreatingSharedSurfaceAnd
cl_dx9_surface_info_khr surfaceInfo = {};
surfaceInfo.shared_handle = reinterpret_cast<HANDLE>(0);
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
MockContext ctx(device1);
ctx.setSharingFunctions(mockSharingFcns);
@ -1194,7 +1341,7 @@ TEST_F(D3D9MultiRootDeviceTest, givenD3DHandleIsNotNullWhenCreatingSharedSurface
auto memoryManager = std::make_unique<MockMM>(*device1->executionEnvironment);
memoryManager->forceGmm = gmm;
auto mockSharingFcns = new NiceMock<MockD3DSharingFunctions<D3DTypesHelper::D3D9>>();
auto mockSharingFcns = new MockD3DSharingFunctions<D3DTypesHelper::D3D9>();
mockSharingFcns->mockTexture2dDesc.Format = D3DFMT_R32F;
mockSharingFcns->mockTexture2dDesc.Height = 10;
mockSharingFcns->mockTexture2dDesc.Width = 10;
@ -1202,7 +1349,8 @@ TEST_F(D3D9MultiRootDeviceTest, givenD3DHandleIsNotNullWhenCreatingSharedSurface
cl_dx9_surface_info_khr surfaceInfo = {};
surfaceInfo.shared_handle = reinterpret_cast<HANDLE>(1);
ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc));
mockSharingFcns->getTexture2dDescSetParams = true;
mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc;
MockContext ctx(device1);
ctx.setSharingFunctions(mockSharingFcns);

61
opencl/test/unit_test/d3d_sharing/d3d_aux_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,7 +19,6 @@
#include "opencl/source/sharings/d3d/d3d_texture.h"
#include "opencl/test/unit_test/fixtures/d3d_test_fixture.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
namespace NEO {
@ -33,9 +32,11 @@ TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithUnifiedAuxFlagsWhenCreatingT
this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -44,6 +45,8 @@ TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithUnifiedAuxFlagsWhenCreatingT
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_TRUE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithUnifiedAuxFlagsWhenFailOnAuxMappingThenDontSetAsCompressed) {
@ -52,10 +55,12 @@ TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithUnifiedAuxFlagsWhenFailOnAux
this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
mockMM->mapAuxGpuVaRetValue = false;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -64,6 +69,8 @@ TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithUnifiedAuxFlagsWhenFailOnAux
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_EQ(!hwInfoConfig.isPageTableManagerSupported(hwInfo), gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithoutUnifiedAuxFlagsWhenCreatingThenDontMapAuxTable) {
@ -73,21 +80,26 @@ TYPED_TEST_P(D3DAuxTests, given2dSharableTextureWithoutUnifiedAuxFlagsWhenCreati
EXPECT_FALSE(gmm->unifiedAuxTranslationCapable());
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
EXPECT_EQ(0u, mockMM->mapAuxGpuVACalled);
EXPECT_FALSE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given2dNonSharableTextureWithUnifiedAuxFlagsWhenCreatingThenMapAuxTableAndSetCompressed) {
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -96,15 +108,19 @@ TYPED_TEST_P(D3DAuxTests, given2dNonSharableTextureWithUnifiedAuxFlagsWhenCreati
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_TRUE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithUnifiedAuxFlagsWhenCreatingThenMapAuxTableAndSetAsCompressed) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -113,16 +129,19 @@ TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithUnifiedAuxFlagsWhenCreatingT
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_TRUE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithUnifiedAuxFlagsWhenFailOnAuxMappingThenDontSetAsCompressed) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
mockMM->mapAuxGpuVaRetValue = false;
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -131,6 +150,7 @@ TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithUnifiedAuxFlagsWhenFailOnAux
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_EQ(!hwInfoConfig.isPageTableManagerSupported(hwInfo), gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithoutUnifiedAuxFlagsWhenCreatingThenDontMapAuxTable) {
@ -138,21 +158,25 @@ TYPED_TEST_P(D3DAuxTests, given3dSharableTextureWithoutUnifiedAuxFlagsWhenCreati
EXPECT_FALSE(gmm->unifiedAuxTranslationCapable());
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
EXPECT_EQ(0u, mockMM->mapAuxGpuVACalled);
EXPECT_FALSE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DAuxTests, given3dNonSharableTextureWithUnifiedAuxFlagsWhenCreatingThenMapAuxTableAndSetCompressed) {
mockGmmResInfo->setUnifiedAuxTranslationCapable();
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _)).Times(1).WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
mockGmmResInfo->setUnifiedAuxTranslationCapable();
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
std::unique_ptr<Image> image(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
const auto &hwInfo = context->getDevice(0)->getHardwareInfo();
@ -161,6 +185,7 @@ TYPED_TEST_P(D3DAuxTests, given3dNonSharableTextureWithUnifiedAuxFlagsWhenCreati
EXPECT_EQ(expectedMapAuxGpuVaCalls, mockMM->mapAuxGpuVACalled);
EXPECT_TRUE(gmm->isCompressionEnabled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
REGISTER_TYPED_TEST_CASE_P(D3DAuxTests,

399
opencl/test/unit_test/d3d_sharing/d3d_tests_part1.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -23,7 +23,6 @@
#include "opencl/test/unit_test/mocks/mock_buffer.h"
#include "opencl/test/unit_test/mocks/mock_sharing_factory.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
namespace NEO {
@ -120,12 +119,8 @@ TYPED_TEST_P(D3DTests, givenNonIntelVendorWhenGetDeviceIdIsCalledThenReturnError
TYPED_TEST_P(D3DTests, WhenCreatingFromD3DBufferKhrApiThenValidBufferIsReturned) {
cl_int retVal;
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
.Times(0);
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, (D3DBufferObj *)&this->dummyD3DBuffer, &retVal);
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -135,171 +130,192 @@ TYPED_TEST_P(D3DTests, WhenCreatingFromD3DBufferKhrApiThenValidBufferIsReturned)
auto bufferObj = static_cast<D3DBuffer<TypeParam> *>(buffer->getSharingHandler().get());
EXPECT_EQ((D3DResource *)&this->dummyD3DBuffer, *bufferObj->getResourceHandler());
EXPECT_EQ(reinterpret_cast<D3DResource *>(&this->dummyD3DBuffer), *bufferObj->getResourceHandler());
EXPECT_TRUE(buffer->getFlags() == CL_MEM_READ_WRITE);
clReleaseMemObject(memObj);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(0u, this->mockSharingFcns->getSharedNTHandleCalled);
}
TYPED_TEST_P(D3DTests, givenNV12FormatAndEvenPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_NV12, ImagePlane::PLANE_Y, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(2u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextWhen2dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
cl_int retCode = 0;
mockMM.get()->verifyValue = false;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, &retCode));
mockMM.get()->verifyValue = true;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextAndNTHandleWhen2dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
cl_int retCode = 0;
mockMM.get()->verifyValue = false;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, &retCode));
mockMM.get()->verifyValue = true;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectAndAlocationFailedWhen2dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
cl_int retCode = 0;
mockMM.get()->failAlloc = true;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, &retCode));
mockMM.get()->failAlloc = false;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectAndNTHandleAndAllocationFailedWhen2dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
cl_int retCode = 0;
mockMM.get()->failAlloc = true;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, &retCode));
mockMM.get()->failAlloc = false;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenNV12FormatAndOddPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_NV12;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 7, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_NV12, ImagePlane::PLANE_UV, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(3u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenP010FormatAndEvenPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P010;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_P010, ImagePlane::PLANE_Y, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(2u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenP010FormatAndOddPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P010;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 7, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_P010, ImagePlane::PLANE_UV, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(3u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenP016FormatAndEvenPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P016;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_P016, ImagePlane::PLANE_Y, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(2u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenP016FormatAndOddPlaneWhen2dCreatedThenSetPlaneParams) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P016;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 7, nullptr));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
ASSERT_NE(nullptr, image.get());
auto expectedFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(DXGI_FORMAT_P016, ImagePlane::PLANE_UV, CL_MEM_READ_WRITE);
EXPECT_TRUE(memcmp(expectedFormat, &image->getSurfaceFormatInfo(), sizeof(SurfaceFormatInfo)) == 0);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
EXPECT_EQ(3u, mockGmmResInfo->arrayIndexPassedToGetOffset);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, WhenCreatingFromD3D2dTextureKhrApiThenValidImageIsReturned) {
cl_int retVal;
EXPECT_CALL(*this->mockSharingFcns, createQuery(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
.Times(0);
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, 1, &retVal);
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), 1, &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
@ -311,27 +327,26 @@ TYPED_TEST_P(D3DTests, WhenCreatingFromD3D2dTextureKhrApiThenValidImageIsReturne
auto textureObj = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
EXPECT_EQ((D3DResource *)&this->dummyD3DTexture, *textureObj->getResourceHandler());
EXPECT_EQ(reinterpret_cast<D3DResource *>(&this->dummyD3DTexture), *textureObj->getResourceHandler());
EXPECT_TRUE(image->getFlags() == CL_MEM_READ_WRITE);
EXPECT_TRUE(image->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE2D);
EXPECT_EQ(1u, textureObj->getSubresource());
clReleaseMemObject(memObj);
EXPECT_EQ(1u, this->mockSharingFcns->createQueryCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(0u, this->mockSharingFcns->getSharedNTHandleCalled);
}
TYPED_TEST_P(D3DTests, WhenCreatingFromD3D3dTextureKhrApiThenValidImageIsReturned) {
cl_int retVal;
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, createQuery(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
auto memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture3d *)&this->dummyD3DTexture, 1, &retVal);
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
auto memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), 1, &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled);
@ -343,32 +358,32 @@ TYPED_TEST_P(D3DTests, WhenCreatingFromD3D3dTextureKhrApiThenValidImageIsReturne
auto textureObj = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
EXPECT_EQ((D3DResource *)&this->dummyD3DTexture, *textureObj->getResourceHandler());
EXPECT_EQ(reinterpret_cast<D3DResource *>(&this->dummyD3DTexture), *textureObj->getResourceHandler());
EXPECT_TRUE(image->getFlags() == CL_MEM_READ_WRITE);
EXPECT_TRUE(image->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE3D);
EXPECT_EQ(1u, textureObj->getSubresource());
clReleaseMemObject(memObj);
EXPECT_EQ(1u, this->mockSharingFcns->createQueryCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(0u, this->mockSharingFcns->getSharedNTHandleCalled);
}
TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreateBufferThenStagingBufferEqualsPassedBuffer) {
std::vector<IUnknown *> releaseExpectedParams{};
{
this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
EXPECT_CALL(*this->mockSharingFcns, createBuffer(_, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DBufferObj *)&this->dummyD3DBuffer, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DBufferObj *)&this->dummyD3DBuffer))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, createQuery(_))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DQuery *)1));
this->mockSharingFcns->getBufferDescSetParams = true;
this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc;
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
this->mockSharingFcns->createQuerySetParams = true;
this->mockSharingFcns->createQueryParamsSet.query = reinterpret_cast<D3DQuery *>(1);
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr));
ASSERT_NE(nullptr, buffer.get());
auto d3dBuffer = static_cast<D3DBuffer<TypeParam> *>(buffer->getSharingHandler().get());
ASSERT_NE(nullptr, d3dBuffer);
@ -377,26 +392,35 @@ TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreateBufferThenStagingBufferE
EXPECT_TRUE(d3dBuffer->isSharedResource());
EXPECT_EQ(&this->dummyD3DBuffer, d3dBuffer->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DBufferObj *)&this->dummyD3DBuffer))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dBuffer->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dBuffer->getQuery()));
EXPECT_EQ(0u, this->mockSharingFcns->createBufferCalled);
EXPECT_EQ(1u, this->mockSharingFcns->createQueryCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getBufferDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(2u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreateBufferThenCreateNewStagingBuffer) {
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, createBuffer(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DBufferObj *)&this->dummyD3DBufferStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DBufferObj *)&this->dummyD3DBufferStaging, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DBufferObj *)&this->dummyD3DBuffer))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, createQuery(_))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DQuery *)1));
std::vector<IUnknown *> releaseExpectedParams{};
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
{
this->mockSharingFcns->createBufferSetParams = true;
this->mockSharingFcns->createBufferParamsSet.buffer = reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging);
this->mockSharingFcns->createQuerySetParams = true;
this->mockSharingFcns->createQueryParamsSet.query = reinterpret_cast<D3DQuery *>(1);
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr));
ASSERT_NE(nullptr, buffer.get());
auto d3dBuffer = static_cast<D3DBuffer<TypeParam> *>(buffer->getSharingHandler().get());
ASSERT_NE(nullptr, d3dBuffer);
@ -405,40 +429,32 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreateBufferThenCreateNewSt
EXPECT_FALSE(d3dBuffer->isSharedResource());
EXPECT_EQ(&this->dummyD3DBufferStaging, d3dBuffer->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DBufferObj *)&this->dummyD3DBufferStaging))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DBufferObj *)&this->dummyD3DBuffer))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dBuffer->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging));
releaseExpectedParams.push_back(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dBuffer->getQuery()));
EXPECT_EQ(1u, this->mockSharingFcns->createBufferCalled);
EXPECT_EQ(1u, this->mockSharingFcns->createQueryCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(3u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
EXPECT_EQ(releaseExpectedParams[2], this->mockSharingFcns->releaseParamsPassed[2].resource);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferWhenAcquiredThenCopySubregion) {
this->context->setInteropUserSyncEnabled(true);
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, createBuffer(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DBufferObj *)&this->dummyD3DBufferStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getDeviceContext(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, copySubresourceRegion((D3DBufferObj *)&this->dummyD3DBufferStaging, 0u, (D3DBufferObj *)&this->dummyD3DBuffer, 0u))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, flushAndWait(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, releaseDeviceContext(_))
.Times(1);
this->mockSharingFcns->createBufferSetParams = true;
this->mockSharingFcns->createBufferParamsSet.buffer = reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging);
EXPECT_CALL(*this->mockSharingFcns, getDeviceContext(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, copySubresourceRegion((D3DBufferObj *)&this->dummyD3DBuffer, 0u, (D3DBufferObj *)&this->dummyD3DBufferStaging, 0u))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, releaseDeviceContext(_))
.Times(1);
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr));
ASSERT_NE(nullptr, buffer.get());
cl_mem bufferMem = (cl_mem)buffer.get();
@ -461,28 +477,33 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferWhenAcquiredThenCopySubregion
retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, this->cmdQ, 1, &bufferMem, 0, nullptr, nullptr);
EXPECT_EQ(this->pickParam(CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR, CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR), retVal);
EXPECT_EQ(0u, buffer->acquireCount);
EXPECT_EQ(1u, this->mockSharingFcns->createBufferCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(2u, this->mockSharingFcns->getDeviceContextCalled);
EXPECT_EQ(2u, this->mockSharingFcns->releaseDeviceContextCalled);
EXPECT_EQ(2u, this->mockSharingFcns->copySubresourceRegionCalled);
EXPECT_EQ(1u, this->mockSharingFcns->flushAndWaitCalled);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging), this->mockSharingFcns->copySubresourceRegionParamsPassed[0].dst);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[0].dstSubresource);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), this->mockSharingFcns->copySubresourceRegionParamsPassed[0].src);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[0].srcSubresource);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), this->mockSharingFcns->copySubresourceRegionParamsPassed[1].dst);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[1].dstSubresource);
EXPECT_EQ(reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBufferStaging), this->mockSharingFcns->copySubresourceRegionParamsPassed[1].src);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[1].srcSubresource);
}
TYPED_TEST_P(D3DTests, givenSharedResourceBufferWhenAcquiredThenDontCopySubregion) {
this->context->setInteropUserSyncEnabled(true);
this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getDeviceContext(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, copySubresourceRegion(_, _, _, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, flushAndWait(_))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, releaseDeviceContext(_))
.Times(1);
this->mockSharingFcns->getBufferDescSetParams = true;
this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc;
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr));
ASSERT_NE(nullptr, buffer.get());
cl_mem bufferMem = (cl_mem)buffer.get();
@ -491,28 +512,23 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferWhenAcquiredThenDontCopySubregio
retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, this->cmdQ, 1, &bufferMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getBufferDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getDeviceContextCalled);
EXPECT_EQ(1u, this->mockSharingFcns->releaseDeviceContextCalled);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionCalled);
EXPECT_EQ(0u, this->mockSharingFcns->flushAndWaitCalled);
}
TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenAcquiredThenFlushOnAcquire) {
this->context->setInteropUserSyncEnabled(false);
this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, getDeviceContext(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, copySubresourceRegion(_, _, _, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, flushAndWait(_))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, releaseDeviceContext(_))
.Times(1);
this->mockSharingFcns->getBufferDescSetParams = true;
this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc;
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr));
ASSERT_NE(nullptr, buffer.get());
cl_mem bufferMem = (cl_mem)buffer.get();
@ -521,6 +537,13 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenAc
retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, this->cmdQ, 1, &bufferMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getBufferDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getDeviceContextCalled);
EXPECT_EQ(1u, this->mockSharingFcns->releaseDeviceContextCalled);
EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionCalled);
EXPECT_EQ(1u, this->mockSharingFcns->flushAndWaitCalled);
}
TYPED_TEST_P(D3DTests, WhenGettingPreferD3DSharedResourcesThenCorrectValueIsReturned) {
@ -543,7 +566,7 @@ TYPED_TEST_P(D3DTests, WhenGettingPreferD3DSharedResourcesThenCorrectValueIsRetu
}
TYPED_TEST_P(D3DTests, WhenGettingD3DResourceInfoFromMemObjThenCorrectInfoIsReturned) {
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, (D3DBufferObj *)&this->dummyD3DBuffer, nullptr);
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), nullptr);
ASSERT_NE(nullptr, memObj);
auto param = this->pickParam(CL_MEM_D3D10_RESOURCE_KHR, CL_MEM_D3D11_RESOURCE_KHR);
@ -561,11 +584,10 @@ TYPED_TEST_P(D3DTests, WhenGettingD3DSubresourceInfoFromMemObjThenCorrectInfoIsR
cl_uint subresource = 1u;
auto param = this->pickParam(CL_IMAGE_D3D10_SUBRESOURCE_KHR, CL_IMAGE_D3D11_SUBRESOURCE_KHR);
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -576,19 +598,21 @@ TYPED_TEST_P(D3DTests, WhenGettingD3DSubresourceInfoFromMemObjThenCorrectInfoIsR
EXPECT_EQ(subresource, retSubresource);
clReleaseMemObject(memObj);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenTheSameD3DBufferWhenNextCreateIsCalledThenFail) {
cl_int retVal;
EXPECT_EQ(0u, this->mockSharingFcns->getTrackedResourcesVector()->size());
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, (D3DBufferObj *)&this->dummyD3DBuffer, &retVal);
auto memObj = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getTrackedResourcesVector()->size());
EXPECT_EQ(0u, this->mockSharingFcns->getTrackedResourcesVector()->at(0).second);
auto memObj2 = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, (D3DBufferObj *)&this->dummyD3DBuffer, &retVal);
auto memObj2 = this->createFromD3DBufferApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DBufferObj *>(&this->dummyD3DBuffer), &retVal);
EXPECT_EQ(nullptr, memObj2);
EXPECT_EQ(this->pickParam(CL_INVALID_D3D10_RESOURCE_KHR, CL_INVALID_D3D11_RESOURCE_KHR), retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getTrackedResourcesVector()->size());
@ -601,28 +625,27 @@ TYPED_TEST_P(D3DTests, givenD3DTextureWithTheSameSubresourceWhenNextCreateIsCall
cl_int retVal;
cl_uint subresource = 1;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
EXPECT_EQ(0u, this->mockSharingFcns->getTrackedResourcesVector()->size());
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getTrackedResourcesVector()->size());
auto memObj2 = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj2 = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
EXPECT_EQ(nullptr, memObj2);
EXPECT_EQ(this->pickParam(CL_INVALID_D3D10_RESOURCE_KHR, CL_INVALID_D3D11_RESOURCE_KHR), retVal);
EXPECT_EQ(1u, this->mockSharingFcns->getTrackedResourcesVector()->size());
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
subresource++;
this->setupMockGmm(); // setup new mock for new resource
auto memObj3 = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj3 = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
ASSERT_NE(nullptr, memObj);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(2u, this->mockSharingFcns->getTrackedResourcesVector()->size());
@ -631,6 +654,8 @@ TYPED_TEST_P(D3DTests, givenD3DTextureWithTheSameSubresourceWhenNextCreateIsCall
EXPECT_EQ(1u, this->mockSharingFcns->getTrackedResourcesVector()->size());
clReleaseMemObject(memObj3);
EXPECT_EQ(0u, this->mockSharingFcns->getTrackedResourcesVector()->size());
EXPECT_EQ(2u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenInvalidSubresourceWhenCreateTexture2dIsCalledThenFail) {
@ -639,22 +664,23 @@ TYPED_TEST_P(D3DTests, givenInvalidSubresourceWhenCreateTexture2dIsCalledThenFai
this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
cl_uint subresource = 16;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
EXPECT_EQ(nullptr, memObj);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
subresource = 20;
memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture2d *)&this->dummyD3DTexture, subresource, &retVal);
memObj = this->createFromD3DTexture2DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), subresource, &retVal);
EXPECT_EQ(nullptr, memObj);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(2u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenInvalidSubresourceWhenCreateTexture3dIsCalledThenFail) {
@ -662,22 +688,23 @@ TYPED_TEST_P(D3DTests, givenInvalidSubresourceWhenCreateTexture3dIsCalledThenFai
this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4;
cl_uint subresource = 16;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
auto memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture3d *)&this->dummyD3DTexture, subresource, &retVal);
auto memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), subresource, &retVal);
EXPECT_EQ(nullptr, memObj);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
subresource = 20;
memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, (D3DTexture3d *)&this->dummyD3DTexture, subresource, &retVal);
memObj = this->createFromD3DTexture3DApi(this->context, CL_MEM_READ_WRITE, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), subresource, &retVal);
EXPECT_EQ(nullptr, memObj);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(2u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenPackedFormatWhenLookingForSurfaceFormatWithPackedNotSupportedThenReturnNull) {

371
opencl/test/unit_test/d3d_sharing/d3d_tests_part2.cpp
View File

@ -21,7 +21,6 @@
#include "opencl/source/sharings/d3d/d3d_texture.h"
#include "opencl/test/unit_test/fixtures/d3d_test_fixture.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
namespace NEO {
@ -31,9 +30,8 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncEnabledWhenRel
this->context->setInteropUserSyncEnabled(true);
this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
this->mockSharingFcns->getBufferDescSetParams = true;
this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc;
class MockCmdQ : public MockCommandQueue {
public:
@ -58,6 +56,8 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncEnabledWhenRel
retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0u, mockCmdQ->finishCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getBufferDescCalled);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice) {
@ -92,9 +92,8 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenRe
this->context->setInteropUserSyncEnabled(false);
this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
this->mockSharingFcns->getBufferDescSetParams = true;
this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc;
class MockCmdQ : public MockCommandQueue {
public:
@ -119,6 +118,8 @@ TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenRe
retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(1u, mockCmdQ->finishCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getBufferDescCalled);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce) {
@ -150,22 +151,17 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncEnabledWhen
}
TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture) {
std::vector<IUnknown *> releaseExpectedParams{};
{
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
this->mockSharingFcns->mockTexture2dDesc.ArraySize = 4;
this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
@ -173,28 +169,36 @@ TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate2dTextureThenStagingText
EXPECT_TRUE(d3dTexture->isSharedResource());
EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dTexture->getQuery()));
EXPECT_EQ(0u, this->mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(2u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture) {
std::vector<IUnknown *> releaseExpectedParams{};
{
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = 0;
::testing::InSequence is;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
mockSharingFcns->createTexture2dSetParams = true;
mockSharingFcns->createTexture2dParamsSet.texture = reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging);
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
@ -202,29 +206,36 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate2dTextureThenCreateSt
EXPECT_FALSE(d3dTexture->isSharedResource());
EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging));
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dTexture->getQuery()));
EXPECT_EQ(1u, this->mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(3u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
EXPECT_EQ(releaseExpectedParams[2], this->mockSharingFcns->releaseParamsPassed[2].resource);
}
TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture) {
std::vector<IUnknown *> releaseExpectedParams{};
{
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
.Times(1);
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 0, nullptr));
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
@ -232,27 +243,36 @@ TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate3dTextureThenStagingText
EXPECT_TRUE(d3dTexture->isSharedResource());
EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dTexture->getQuery()));
EXPECT_EQ(0u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(2u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
}
TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture) {
std::vector<IUnknown *> releaseExpectedParams{};
{
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = 0;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
.Times(1);
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
@ -260,12 +280,23 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate3dTextureThenCreateSt
EXPECT_FALSE(d3dTexture->isSharedResource());
EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
.Times(1);
EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
.Times(1);
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging));
releaseExpectedParams.push_back(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture));
releaseExpectedParams.push_back(reinterpret_cast<D3DQuery *>(d3dTexture->getQuery()));
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->addRefCalled);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource);
EXPECT_EQ(reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), this->mockSharingFcns->addRefParamsPassed[0].resource);
}
EXPECT_EQ(3u, this->mockSharingFcns->releaseCalled);
EXPECT_EQ(releaseExpectedParams[0], this->mockSharingFcns->releaseParamsPassed[0].resource);
EXPECT_EQ(releaseExpectedParams[1], this->mockSharingFcns->releaseParamsPassed[1].resource);
EXPECT_EQ(releaseExpectedParams[2], this->mockSharingFcns->releaseParamsPassed[2].resource);
}
TYPED_TEST_P(D3DTests, givenD3DDeviceParamWhenContextCreationThenSetProperValues) {
@ -286,41 +317,41 @@ TYPED_TEST_P(D3DTests, givenD3DDeviceParamWhenContextCreationThenSetProperValues
TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle) {
this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
.Times(1);
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
mockSharingFcns->createTexture2dSetParams = true;
mockSharingFcns->createTexture2dParamsSet.texture = reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTextureStaging);
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture2dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
EXPECT_EQ(0u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedNTHandleCalled);
}
TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
.Times(0);
EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
.Times(1);
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
ASSERT_NE(nullptr, d3dTexture);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
EXPECT_EQ(0u, this->mockSharingFcns->getSharedHandleCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getSharedNTHandleCalled);
}
TYPED_TEST_P(D3DTests, WhenFillingBufferDescThenBufferContentIsCorrect) {
@ -438,41 +469,44 @@ TYPED_TEST_P(D3DTests, GivenForced32BitAddressingWhenCreatingBufferThenBufferHas
TYPED_TEST_P(D3DTests, givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P016;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
ASSERT_NE(nullptr, image.get());
ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
EXPECT_EQ(AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
ASSERT_NE(nullptr, image.get());
ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
EXPECT_EQ(AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
cl_int retCode = 0;
mockMM.get()->verifyValue = false;
@ -480,17 +514,19 @@ TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextWhen3dCreatedThenRetur
mockMM.get()->verifyValue = true;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
cl_int retCode = 0;
mockMM.get()->verifyValue = false;
@ -498,17 +534,19 @@ TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreat
mockMM.get()->verifyValue = true;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
cl_int retCode = 0;
mockMM.get()->failAlloc = true;
@ -516,17 +554,19 @@ TYPED_TEST_P(D3DTests, givenSharedObjectAndAlocationFailedWhen3dCreatedThenRetur
mockMM.get()->failAlloc = false;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode) {
this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
.Times(1)
.WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
this->mockSharingFcns->createTexture3dSetParams = true;
this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging);
cl_int retCode = 0;
mockMM.get()->failAlloc = true;
@ -534,6 +574,9 @@ TYPED_TEST_P(D3DTests, givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCrea
mockMM.get()->failAlloc = false;
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
EXPECT_EQ(1u, this->mockSharingFcns->createTexture3dCalled);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
TYPED_TEST_P(D3DTests, givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned) {
@ -562,17 +605,10 @@ TYPED_TEST_P(D3DTests, givenFormatNotSupportedByDxWhenGettingSupportedFormatsThe
DXGI_FORMAT_V408,
DXGI_FORMAT_FORCE_UINT};
auto checkFormat = [&](DXGI_FORMAT format, UINT *pFormat) -> bool {
auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
if (iter != unsupportedDXGIformats.end()) {
return false;
}
*pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
return true;
};
ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
mockSharingFcns->checkFormatSupportSetParam1 = true;
mockSharingFcns->checkUnsupportedDXGIformats = true;
mockSharingFcns->checkFormatSupportParamsSet.pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
mockSharingFcns->unsupportedDXGIformats = unsupportedDXGIformats;
std::vector<DXGI_FORMAT> formats;
cl_uint numTextureFormats = 0;
@ -596,69 +632,50 @@ TYPED_TEST_P(D3DTests, givenFormatNotSupportedByDxWhenGettingSupportedFormatsThe
}
TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned) {
mockSharingFcns->checkFormatSupportSetParam1 = true;
mockSharingFcns->checkUnsupportedDXGIformats = true;
mockSharingFcns->checkFormatSupportSetParam0 = true;
mockSharingFcns->checkFormatSupportParamsSet.pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
mockSharingFcns->checkFormatSupportParamsSet.format = DXGI_FORMAT_R32_FLOAT;
mockSharingFcns->unsupportedDXGIformats = {DXGI_FORMAT_R32_FLOAT};
auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
if (format == DXGI_FORMAT_R32_FLOAT) {
return false;
}
*pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
return true;
};
auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
return mockSharingFcns->validateFormatSupportBase(format, type);
};
ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
.WillByDefault(::testing::Invoke(validate));
mockSharingFcns->callBaseValidateFormatSupport = true;
this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_R32_FLOAT;
EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
this->mockSharingFcns->getTexture2dDescSetParams = true;
this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc;
cl_int retCode = CL_SUCCESS;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture2dDescCalled);
}
TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned) {
mockSharingFcns->checkFormatSupportSetParam1 = true;
mockSharingFcns->checkUnsupportedDXGIformats = true;
mockSharingFcns->checkFormatSupportSetParam0 = true;
mockSharingFcns->checkFormatSupportParamsSet.pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
mockSharingFcns->checkFormatSupportParamsSet.format = DXGI_FORMAT_R32_FLOAT;
mockSharingFcns->unsupportedDXGIformats = {DXGI_FORMAT_R32_FLOAT};
auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
if (format == DXGI_FORMAT_R32_FLOAT) {
return false;
}
*pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
return true;
};
auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
return mockSharingFcns->validateFormatSupportBase(format, type);
};
ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
.WillByDefault(::testing::Invoke(validate));
mockSharingFcns->callBaseValidateFormatSupport = true;
this->mockSharingFcns->mockTexture3dDesc.Format = DXGI_FORMAT_R32_FLOAT;
EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
.Times(1)
.WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
this->mockSharingFcns->getTexture3dDescSetParams = true;
this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc;
cl_int retCode = CL_SUCCESS;
auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
EXPECT_EQ(nullptr, image.get());
EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
EXPECT_EQ(1u, this->mockSharingFcns->getTexture3dDescCalled);
}
REGISTER_TYPED_TEST_CASE_P(D3DTests,

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

@ -101,9 +101,9 @@ class D3DTests : public PlatformFixture, public ::testing::Test {
context->preferD3dSharedResources = true;
mockMM = std::make_unique<MockMM>(*context->getDevice(0)->getExecutionEnvironment());
mockSharingFcns = new NiceMock<MockD3DSharingFunctions<T>>();
auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool { *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D; return true; };
ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
mockSharingFcns = new MockD3DSharingFunctions<T>();
mockSharingFcns->checkFormatSupportSetParam1 = true;
mockSharingFcns->checkFormatSupportParamsSet.pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
context->setSharingFunctions(mockSharingFcns);
context->memoryManager = mockMM.get();
@ -193,7 +193,7 @@ class D3DTests : public PlatformFixture, public ::testing::Test {
return clGetDeviceIDsFromD3D11KHR(platform, d3dDeviceSource, d3dObject, d3dDeviceSet, numEntries, devices, numDevices);
}
NiceMock<MockD3DSharingFunctions<T>> *mockSharingFcns;
MockD3DSharingFunctions<T> *mockSharingFcns;
MockContext *context;
MockCommandQueue *cmdQ;
char dummyD3DBuffer;

318
opencl/test/unit_test/mocks/mock_d3d_objects.h
View File

@ -1,17 +1,16 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "opencl/source/sharings/d3d/d3d_sharing.h"
#include "gmock/gmock.h"
using ::testing::_;
using ::testing::NiceMock;
using ::testing::SetArgPointee;
#include "gtest/gtest.h"
namespace NEO {
template <typename D3D>
@ -36,29 +35,286 @@ class MockD3DSharingFunctions : public D3DSharingFunctions<D3D> {
getDxgiDescAdapterRequested = nullptr;
}
MOCK_METHOD1_T(createQuery, void(D3DQuery **query));
MOCK_METHOD2_T(createBuffer, void(D3DBufferObj **buffer, unsigned int width));
MOCK_METHOD3_T(createTexture2d, void(D3DTexture2d **texture, D3DTexture2dDesc *desc, cl_uint subresource));
MOCK_METHOD3_T(createTexture3d, void(D3DTexture3d **texture, D3DTexture3dDesc *desc, cl_uint subresource));
MOCK_METHOD2_T(getBufferDesc, void(D3DBufferDesc *bufferDesc, D3DBufferObj *buffer));
MOCK_METHOD2_T(getTexture2dDesc, void(D3DTexture2dDesc *textureDesc, D3DTexture2d *texture));
MOCK_METHOD2_T(getTexture3dDesc, void(D3DTexture3dDesc *textureDesc, D3DTexture3d *texture));
MOCK_METHOD2_T(getSharedHandle, void(D3DResource *resource, void **handle));
MOCK_METHOD2_T(getSharedNTHandle, void(D3DResource *resource, void **handle));
MOCK_METHOD1_T(addRef, void(D3DResource *resource));
MOCK_METHOD1_T(release, void(IUnknown *resource));
MOCK_METHOD1_T(getDeviceContext, void(D3DQuery *query));
MOCK_METHOD1_T(releaseDeviceContext, void(D3DQuery *query));
MOCK_METHOD4_T(copySubresourceRegion, void(D3DResource *dst, cl_uint dstSubresource, D3DResource *src, cl_uint srcSubresource));
MOCK_METHOD1_T(flushAndWait, void(D3DQuery *query));
MOCK_METHOD3_T(lockRect, void(D3DTexture2d *d3dResource, D3DLOCKED_RECT *lockedRect, uint32_t flags));
MOCK_METHOD1_T(unlockRect, void(D3DTexture2d *d3dResource));
MOCK_METHOD2_T(getRenderTargetData, void(D3DTexture2d *renderTarget, D3DTexture2d *dstSurface));
MOCK_METHOD2_T(updateSurface, void(D3DTexture2d *src, D3DTexture2d *dst));
MOCK_METHOD1_T(updateDevice, void(D3DResource *resource));
MOCK_METHOD2_T(checkFormatSupport, bool(DXGI_FORMAT format, UINT *pFormat));
MOCK_METHOD2_T(memObjectFormatSupport, bool(cl_mem_object_type object, UINT format));
MOCK_METHOD2_T(validateFormatSupport, cl_int(DXGI_FORMAT format, cl_mem_object_type type));
void createQuery(D3DQuery **query) override {
createQueryCalled++;
if (createQuerySetParams) {
*query = createQueryParamsSet.query;
}
}
struct CreateQueryParams {
D3DQuery *query{};
};
uint32_t createQueryCalled = 0u;
CreateQueryParams createQueryParamsSet{};
bool createQuerySetParams = false;
void createBuffer(D3DBufferObj **buffer, unsigned int width) override {
createBufferCalled++;
if (createBufferSetParams) {
*buffer = createBufferParamsSet.buffer;
}
}
struct CreateBufferParams {
D3DBufferObj *buffer{};
unsigned int width{};
};
uint32_t createBufferCalled = 0u;
CreateBufferParams createBufferParamsSet{};
bool createBufferSetParams = false;
void createTexture2d(D3DTexture2d **texture, D3DTexture2dDesc *desc, cl_uint subresource) override {
createTexture2dCalled++;
if (createTexture2dSetParams) {
*texture = createTexture2dParamsSet.texture;
}
}
struct CreateTexture2dParams {
D3DTexture2d *texture{};
D3DTexture2dDesc *desc{};
cl_uint subresource{};
};
uint32_t createTexture2dCalled = 0u;
CreateTexture2dParams createTexture2dParamsSet{};
bool createTexture2dSetParams = false;
void createTexture3d(D3DTexture3d **texture, D3DTexture3dDesc *desc, cl_uint subresource) override {
createTexture3dCalled++;
if (createTexture3dSetParams) {
*texture = createTexture3dParamsSet.texture;
}
}
struct CreateTexture3dParams {
D3DTexture3d *texture{};
D3DTexture3dDesc *desc{};
cl_uint subresource{};
};
uint32_t createTexture3dCalled = 0u;
CreateTexture3dParams createTexture3dParamsSet{};
bool createTexture3dSetParams = false;
void getBufferDesc(D3DBufferDesc *bufferDesc, D3DBufferObj *buffer) override {
getBufferDescCalled++;
if (getBufferDescSetParams) {
*bufferDesc = getBufferDescParamsSet.bufferDesc;
}
}
struct GetBufferDescParams {
D3DBufferDesc bufferDesc{};
D3DBufferObj *buffer{};
};
uint32_t getBufferDescCalled = 0u;
GetBufferDescParams getBufferDescParamsSet{};
bool getBufferDescSetParams = false;
void getTexture2dDesc(D3DTexture2dDesc *textureDesc, D3DTexture2d *texture) override {
getTexture2dDescCalled++;
if (getTexture2dDescSetParams) {
*textureDesc = getTexture2dDescParamsSet.textureDesc;
}
}
struct GetTexture2dDescParams {
D3DTexture2dDesc textureDesc{};
D3DTexture2d *texture{};
};
uint32_t getTexture2dDescCalled = 0u;
GetTexture2dDescParams getTexture2dDescParamsSet{};
bool getTexture2dDescSetParams = false;
void getTexture3dDesc(D3DTexture3dDesc *textureDesc, D3DTexture3d *texture) override {
getTexture3dDescCalled++;
if (getTexture3dDescSetParams) {
*textureDesc = getTexture3dDescParamsSet.textureDesc;
}
}
struct GetTexture3dDescParams {
D3DTexture3dDesc textureDesc{};
D3DTexture3d *texture{};
};
uint32_t getTexture3dDescCalled = 0u;
GetTexture3dDescParams getTexture3dDescParamsSet{};
bool getTexture3dDescSetParams = false;
void getSharedHandle(D3DResource *resource, void **handle) override {
getSharedHandleCalled++;
getSharedHandleParamsPassed.push_back({resource, handle});
}
struct GetSharedHandleParams {
D3DResource *resource{};
void **handle{};
};
uint32_t getSharedHandleCalled = 0u;
StackVec<GetSharedHandleParams, 1> getSharedHandleParamsPassed{};
void addRef(D3DResource *resource) override {
addRefCalled++;
addRefParamsPassed.push_back({resource});
}
struct AddRefParams {
D3DResource *resource{};
};
uint32_t addRefCalled = 0u;
StackVec<AddRefParams, 1> addRefParamsPassed{};
void release(IUnknown *resource) override {
releaseCalled++;
releaseParamsPassed.push_back({resource});
}
struct ReleaseParams {
IUnknown *resource{};
};
uint32_t releaseCalled = 0u;
StackVec<ReleaseParams, 3> releaseParamsPassed{};
void copySubresourceRegion(D3DResource *dst, cl_uint dstSubresource, D3DResource *src, cl_uint srcSubresource) override {
copySubresourceRegionCalled++;
copySubresourceRegionParamsPassed.push_back({dst, dstSubresource, src, srcSubresource});
}
struct CopySubresourceRegionParams {
D3DResource *dst{};
cl_uint dstSubresource{};
D3DResource *src{};
cl_uint srcSubresource{};
};
uint32_t copySubresourceRegionCalled = 0u;
StackVec<CopySubresourceRegionParams, 2> copySubresourceRegionParamsPassed{};
void lockRect(D3DTexture2d *d3dResource, D3DLOCKED_RECT *lockedRect, uint32_t flags) override {
lockRectCalled++;
if (lockRectSetParams) {
*lockedRect = lockRectParamsSet.lockedRect;
}
lockRectParamsPassed.push_back({d3dResource, *lockedRect, flags});
}
struct LockRectParams {
D3DTexture2d *d3dResource{};
D3DLOCKED_RECT lockedRect{};
uint32_t flags{};
};
uint32_t lockRectCalled = 0u;
LockRectParams lockRectParamsSet{};
bool lockRectSetParams = false;
StackVec<LockRectParams, 2> lockRectParamsPassed{};
void unlockRect(D3DTexture2d *d3dResource) override {
unlockRectCalled++;
unlockRectParamsPassed.push_back({d3dResource});
}
struct UnlockRectParams {
D3DTexture2d *d3dResource{};
};
uint32_t unlockRectCalled = 0u;
StackVec<UnlockRectParams, 2> unlockRectParamsPassed{};
void getRenderTargetData(D3DTexture2d *renderTarget, D3DTexture2d *dstSurface) override {
getRenderTargetDataCalled++;
getRenderTargetDataParamsPassed.push_back({renderTarget, dstSurface});
}
struct GetRenderTargetDataParams {
D3DTexture2d *renderTarget{};
D3DTexture2d *dstSurface{};
};
uint32_t getRenderTargetDataCalled = 0u;
StackVec<GetRenderTargetDataParams, 1> getRenderTargetDataParamsPassed{};
void updateSurface(D3DTexture2d *renderTarget, D3DTexture2d *dstSurface) override {
updateSurfaceCalled++;
updateSurfaceParamsPassed.push_back({renderTarget, dstSurface});
}
struct UpdateSurfaceParams {
D3DTexture2d *renderTarget{};
D3DTexture2d *dstSurface{};
};
uint32_t updateSurfaceCalled = 0u;
StackVec<UpdateSurfaceParams, 1> updateSurfaceParamsPassed{};
void updateDevice(D3DResource *resource) override {
updateDeviceCalled++;
updateDeviceParamsPassed.push_back({resource});
}
struct UpdateDeviceParams {
D3DResource *resource{};
};
uint32_t updateDeviceCalled = 0u;
StackVec<UpdateDeviceParams, 1> updateDeviceParamsPassed{};
bool checkFormatSupport(DXGI_FORMAT format, UINT *pFormat) override {
checkFormatSupportCalled++;
if (nullptr == pFormat) {
return false;
}
if (checkFormatSupportSetParam0) {
format = checkFormatSupportParamsSet.format;
}
if (checkFormatSupportSetParam1) {
*pFormat = checkFormatSupportParamsSet.pFormat;
}
if (checkUnsupportedDXGIformats) {
auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
if (iter != unsupportedDXGIformats.end()) {
*pFormat = {};
return false;
}
return true;
}
return checkFormatSupportResult;
}
struct CheckFormatSupportParams {
DXGI_FORMAT format{};
UINT pFormat{};
};
uint32_t checkFormatSupportCalled = 0u;
CheckFormatSupportParams checkFormatSupportParamsSet{};
bool checkFormatSupportResult = true;
bool checkFormatSupportSetParam0 = false;
bool checkFormatSupportSetParam1 = false;
bool checkUnsupportedDXGIformats = false;
std::vector<DXGI_FORMAT> unsupportedDXGIformats{};
cl_int validateFormatSupport(DXGI_FORMAT format, cl_mem_object_type type) override {
validateFormatSupportCalled++;
if (callBaseValidateFormatSupport) {
validateFormatSupportResult = validateFormatSupportBase(format, type);
}
return validateFormatSupportResult;
}
uint32_t validateFormatSupportCalled = 0u;
cl_int validateFormatSupportResult = CL_SUCCESS;
bool callBaseValidateFormatSupport = false;
cl_int validateFormatSupportBase(DXGI_FORMAT format, cl_mem_object_type type) {
return D3DSharingFunctions<D3D>::validateFormatSupport(format, type);
@ -78,5 +334,11 @@ class MockD3DSharingFunctions : public D3DSharingFunctions<D3D> {
getDxgiDescAdapterRequested = adapter;
*dxgiDesc = mockDxgiDesc;
}
ADDMETHOD_NOBASE(memObjectFormatSupport, bool, true, (cl_mem_object_type object, UINT format));
ADDMETHOD_NOBASE_VOIDRETURN(getSharedNTHandle, (D3DResource * resource, void **handle));
ADDMETHOD_NOBASE_VOIDRETURN(getDeviceContext, (D3DQuery * query));
ADDMETHOD_NOBASE_VOIDRETURN(releaseDeviceContext, (D3DQuery * query));
ADDMETHOD_NOBASE_VOIDRETURN(flushAndWait, (D3DQuery * query));
};
} // namespace NEO