From 63ae26715e6aef487686315c520df71e6747bcfb Mon Sep 17 00:00:00 2001 From: Fabian Zwolinski Date: Fri, 11 Feb 2022 15:25:20 +0000 Subject: [PATCH] Remove GMock from MockD3DSharingFunctions Related-To: NEO-4914 Signed-off-by: Fabian Zwolinski --- .../d3d_sharing/cl_dx_sharing_tests.cpp | 13 +- .../test/unit_test/d3d_sharing/d3d9_tests.cpp | 358 ++++++++++----- .../unit_test/d3d_sharing/d3d_aux_tests.cpp | 61 ++- .../unit_test/d3d_sharing/d3d_tests_part1.cpp | 425 ++++++++++-------- .../unit_test/d3d_sharing/d3d_tests_part2.cpp | 425 +++++++++--------- .../unit_test/fixtures/d3d_test_fixture.h | 8 +- .../test/unit_test/mocks/mock_d3d_objects.h | 318 +++++++++++-- 7 files changed, 1042 insertions(+), 566 deletions(-) diff --git a/opencl/test/unit_test/d3d_sharing/cl_dx_sharing_tests.cpp b/opencl/test/unit_test/d3d_sharing/cl_dx_sharing_tests.cpp index d4f004610d..b7d2a0ecd1 100644 --- a/opencl/test/unit_test/d3d_sharing/cl_dx_sharing_tests.cpp +++ b/opencl/test/unit_test/d3d_sharing/cl_dx_sharing_tests.cpp @@ -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 retrievedFormats; ArrayRef availableFormats; - NiceMock> *mockSharingFcns; + MockD3DSharingFunctions *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>(); + mockSharingFcns = new MockD3DSharingFunctions(); 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(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(retrievedFormats.size()), &retrievedFormats[0], &numImageFormats); diff --git a/opencl/test/unit_test/d3d_sharing/d3d9_tests.cpp b/opencl/test/unit_test/d3d_sharing/d3d9_tests.cpp index 88676b1b4d..e9d5351373 100644 --- a/opencl/test/unit_test/d3d_sharing/d3d9_tests.cpp +++ b/opencl/test/unit_test/d3d_sharing/d3d9_tests.cpp @@ -96,12 +96,12 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test { context->preferD3dSharedResources = true; context->memoryManager = memoryManager.get(); - mockSharingFcns = new NiceMock>(); + mockSharingFcns = new MockD3DSharingFunctions(); context->setSharingFunctions(mockSharingFcns); cmdQ = new MockCommandQueue(context, context->getDevice(0), 0, false); DebugManager.injectFcn = &mockSharingFcns->mockGetDxgiDesc; - surfaceInfo.resource = (IDirect3DSurface9 *)&dummyD3DSurface; + surfaceInfo.resource = reinterpret_cast(&dummyD3DSurface); mockSharingFcns->mockTexture2dDesc.Format = D3DFMT_R32F; mockSharingFcns->mockTexture2dDesc.Height = 10; @@ -119,7 +119,7 @@ class D3D9Tests : public PlatformFixture, public ::testing::Test { PlatformFixture::TearDown(); } - NiceMock> *mockSharingFcns; + MockD3DSharingFunctions *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>()); - EXPECT_TRUE((D3DDevice *)&expectedDevice == ctx->getSharing>()->getDevice()); + EXPECT_TRUE(reinterpret_cast(&expectedDevice) == ctx->getSharing>()->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(&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(&dummyD3DSurface), mockSharingFcns->updateDeviceParamsPassed[0].resource); } TEST_F(D3D9Tests, givenD3DHandleWhenCreatingSharedSurfaceThenAllocationTypeImageIsSet) { mockSharingFcns->mockTexture2dDesc.Format = (D3DFORMAT)MAKEFOURCC('Y', 'V', '1', '2'); surfaceInfo.shared_handle = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(1); + + mockSharingFcns->getTexture2dDescSetParams = true; + mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc; std::unique_ptr 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(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(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(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(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(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(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(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(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(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(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(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(&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(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(&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(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(&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(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(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(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[0].d3dResource); + EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[1].d3dResource); + EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags); + + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[0].d3dResource); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[1].d3dResource); + + EXPECT_EQ(reinterpret_cast(&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(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(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(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[0].d3dResource); + EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->lockRectParamsPassed[1].d3dResource); + EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags); + + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[0].d3dResource); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->unlockRectParamsPassed[1].d3dResource); + + EXPECT_EQ(reinterpret_cast(&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(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(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(&dummyD3DSurfaceStaging), mockSharingFcns->lockRectParamsPassed[0].d3dResource); + EXPECT_EQ(D3DLOCK_READONLY, mockSharingFcns->lockRectParamsPassed[0].flags); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurfaceStaging), mockSharingFcns->lockRectParamsPassed[1].d3dResource); + EXPECT_EQ(0u, mockSharingFcns->lockRectParamsPassed[1].flags); + + EXPECT_EQ(reinterpret_cast(&dummyD3DSurfaceStaging), mockSharingFcns->unlockRectParamsPassed[0].d3dResource); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurfaceStaging), mockSharingFcns->unlockRectParamsPassed[1].d3dResource); + + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->getRenderTargetDataParamsPassed[0].renderTarget); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurfaceStaging), mockSharingFcns->getRenderTargetDataParamsPassed[0].dstSurface); + + EXPECT_EQ(reinterpret_cast(&dummyD3DSurfaceStaging), mockSharingFcns->updateSurfaceParamsPassed[0].renderTarget); + EXPECT_EQ(reinterpret_cast(&dummyD3DSurface), mockSharingFcns->updateSurfaceParamsPassed[0].dstSurface); + + EXPECT_EQ(reinterpret_cast(&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(123); mockSharingFcns->setDevice(createdResourceDevice); // create call will pick this device auto sharedImg = std::unique_ptr(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(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(*device1->executionEnvironment); memoryManager->forceGmm = gmm; - auto mockSharingFcns = new NiceMock>(); + auto mockSharingFcns = new MockD3DSharingFunctions(); 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(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(*device1->executionEnvironment); memoryManager->forceGmm = gmm; - auto mockSharingFcns = new NiceMock>(); + auto mockSharingFcns = new MockD3DSharingFunctions(); 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(1); - ON_CALL(*mockSharingFcns, getTexture2dDesc(_, _)).WillByDefault(SetArgPointee<0>(mockSharingFcns->mockTexture2dDesc)); + mockSharingFcns->getTexture2dDescSetParams = true; + mockSharingFcns->getTexture2dDescParamsSet.textureDesc = mockSharingFcns->mockTexture2dDesc; MockContext ctx(device1); ctx.setSharingFunctions(mockSharingFcns); diff --git a/opencl/test/unit_test/d3d_sharing/d3d_aux_tests.cpp b/opencl/test/unit_test/d3d_sharing/d3d_aux_tests.cpp index 660bc6c1da..60410e67fb 100644 --- a/opencl/test/unit_test/d3d_sharing/d3d_aux_tests.cpp +++ b/opencl/test/unit_test/d3d_sharing/d3d_aux_tests.cpp @@ -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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr)); + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr)); + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::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(D3DTexture::create3d(this->context, reinterpret_cast(&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(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + std::unique_ptr image(D3DTexture::create3d(this->context, reinterpret_cast(&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(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + std::unique_ptr image(D3DTexture::create3d(this->context, reinterpret_cast(&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(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + std::unique_ptr image(D3DTexture::create3d(this->context, reinterpret_cast(&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, diff --git a/opencl/test/unit_test/d3d_sharing/d3d_tests_part1.cpp b/opencl/test/unit_test/d3d_sharing/d3d_tests_part1.cpp index 3378d75d1e..f162066f89 100644 --- a/opencl/test/unit_test/d3d_sharing/d3d_tests_part1.cpp +++ b/opencl/test/unit_test/d3d_sharing/d3d_tests_part1.cpp @@ -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(&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 *>(buffer->getSharingHandler().get()); - EXPECT_EQ((D3DResource *)&this->dummyD3DBuffer, *bufferObj->getResourceHandler()); + EXPECT_EQ(reinterpret_cast(&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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(D3DTexture::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(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr)); ASSERT_NE(nullptr, image.get()); auto expectedFormat = D3DTexture::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(&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 *>(image->getSharingHandler().get()); - EXPECT_EQ((D3DResource *)&this->dummyD3DTexture, *textureObj->getResourceHandler()); + EXPECT_EQ(reinterpret_cast(&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(&this->dummyD3DTexture), 1, &retVal); ASSERT_NE(nullptr, memObj); EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(1u, mockGmmResInfo->getOffsetCalled); @@ -343,102 +358,103 @@ TYPED_TEST_P(D3DTests, WhenCreatingFromD3D3dTextureKhrApiThenValidImageIsReturne auto textureObj = static_cast *>(image->getSharingHandler().get()); - EXPECT_EQ((D3DResource *)&this->dummyD3DTexture, *textureObj->getResourceHandler()); + EXPECT_EQ(reinterpret_cast(&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) { - this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; + std::vector releaseExpectedParams{}; - ::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->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; - auto buffer = std::unique_ptr(D3DBuffer::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr)); - ASSERT_NE(nullptr, buffer.get()); - auto d3dBuffer = static_cast *>(buffer->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dBuffer); + this->mockSharingFcns->getBufferDescSetParams = true; + this->mockSharingFcns->getBufferDescParamsSet.bufferDesc = this->mockSharingFcns->mockBufferDesc; - EXPECT_NE(nullptr, d3dBuffer->getQuery()); - EXPECT_TRUE(d3dBuffer->isSharedResource()); - EXPECT_EQ(&this->dummyD3DBuffer, d3dBuffer->getResourceStaging()); + this->mockSharingFcns->createQuerySetParams = true; + this->mockSharingFcns->createQueryParamsSet.query = reinterpret_cast(1); - EXPECT_CALL(*this->mockSharingFcns, release((D3DBufferObj *)&this->dummyD3DBuffer)) - .Times(1); - EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dBuffer->getQuery())) - .Times(1); + auto buffer = std::unique_ptr(D3DBuffer::create(this->context, reinterpret_cast(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr)); + ASSERT_NE(nullptr, buffer.get()); + auto d3dBuffer = static_cast *>(buffer->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dBuffer); + + EXPECT_NE(nullptr, d3dBuffer->getQuery()); + EXPECT_TRUE(d3dBuffer->isSharedResource()); + EXPECT_EQ(&this->dummyD3DBuffer, d3dBuffer->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DBuffer)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DBuffer), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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 releaseExpectedParams{}; - auto buffer = std::unique_ptr(D3DBuffer::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr)); - ASSERT_NE(nullptr, buffer.get()); - auto d3dBuffer = static_cast *>(buffer->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dBuffer); + { + this->mockSharingFcns->createBufferSetParams = true; + this->mockSharingFcns->createBufferParamsSet.buffer = reinterpret_cast(&this->dummyD3DBufferStaging); - EXPECT_NE(nullptr, d3dBuffer->getQuery()); - EXPECT_FALSE(d3dBuffer->isSharedResource()); - EXPECT_EQ(&this->dummyD3DBufferStaging, d3dBuffer->getResourceStaging()); + this->mockSharingFcns->createQuerySetParams = true; + this->mockSharingFcns->createQueryParamsSet.query = reinterpret_cast(1); - 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); + auto buffer = std::unique_ptr(D3DBuffer::create(this->context, reinterpret_cast(&this->dummyD3DBuffer), CL_MEM_READ_WRITE, nullptr)); + ASSERT_NE(nullptr, buffer.get()); + auto d3dBuffer = static_cast *>(buffer->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dBuffer); + + EXPECT_NE(nullptr, d3dBuffer->getQuery()); + EXPECT_FALSE(d3dBuffer->isSharedResource()); + EXPECT_EQ(&this->dummyD3DBufferStaging, d3dBuffer->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DBufferStaging)); + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DBuffer)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DBufferStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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(&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(D3DBuffer::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr)); + auto buffer = std::unique_ptr(D3DBuffer::create(this->context, reinterpret_cast(&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(&this->dummyD3DBufferStaging), this->mockSharingFcns->copySubresourceRegionParamsPassed[0].dst); + EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[0].dstSubresource); + EXPECT_EQ(reinterpret_cast(&this->dummyD3DBuffer), this->mockSharingFcns->copySubresourceRegionParamsPassed[0].src); + EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[0].srcSubresource); + + EXPECT_EQ(reinterpret_cast(&this->dummyD3DBuffer), this->mockSharingFcns->copySubresourceRegionParamsPassed[1].dst); + EXPECT_EQ(0u, this->mockSharingFcns->copySubresourceRegionParamsPassed[1].dstSubresource); + EXPECT_EQ(reinterpret_cast(&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(D3DBuffer::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr)); + auto buffer = std::unique_ptr(D3DBuffer::create(this->context, reinterpret_cast(&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(D3DBuffer::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr)); + auto buffer = std::unique_ptr(D3DBuffer::create(this->context, reinterpret_cast(&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(&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(&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(&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(&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(&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(&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(&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(&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(&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(&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(&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) { diff --git a/opencl/test/unit_test/d3d_sharing/d3d_tests_part2.cpp b/opencl/test/unit_test/d3d_sharing/d3d_tests_part2.cpp index f412173623..bcab72ec13 100644 --- a/opencl/test/unit_test/d3d_sharing/d3d_tests_part2.cpp +++ b/opencl/test/unit_test/d3d_sharing/d3d_tests_part2.cpp @@ -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,122 +151,152 @@ TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncEnabledWhen } TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture) { - this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; - this->mockSharingFcns->mockTexture2dDesc.ArraySize = 4; - this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4; + std::vector releaseExpectedParams{}; - ::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->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; + this->mockSharingFcns->mockTexture2dDesc.ArraySize = 4; + this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4; - auto image = std::unique_ptr(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr)); - ASSERT_NE(nullptr, image.get()); - auto d3dTexture = static_cast *>(image->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dTexture); + this->mockSharingFcns->getTexture2dDescSetParams = true; + this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc; - EXPECT_TRUE(d3dTexture->isSharedResource()); - EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging()); + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 4, nullptr)); + ASSERT_NE(nullptr, image.get()); + auto d3dTexture = static_cast *>(image->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dTexture); - EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture)) - .Times(1); - EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery())) - .Times(1); + EXPECT_TRUE(d3dTexture->isSharedResource()); + EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTexture)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DTexture), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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) { - this->mockSharingFcns->mockTexture2dDesc.MiscFlags = 0; + std::vector releaseExpectedParams{}; - ::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->mockTexture2dDesc.MiscFlags = 0; - auto image = std::unique_ptr(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); - ASSERT_NE(nullptr, image.get()); - auto d3dTexture = static_cast *>(image->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dTexture); + this->mockSharingFcns->getTexture2dDescSetParams = true; + this->mockSharingFcns->getTexture2dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture2dDesc; - EXPECT_FALSE(d3dTexture->isSharedResource()); - EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging()); + mockSharingFcns->createTexture2dSetParams = true; + mockSharingFcns->createTexture2dParamsSet.texture = reinterpret_cast(&this->dummyD3DTextureStaging); - 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); + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr)); + ASSERT_NE(nullptr, image.get()); + auto d3dTexture = static_cast *>(image->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dTexture); + + EXPECT_FALSE(d3dTexture->isSharedResource()); + EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTextureStaging)); + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTexture)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DTextureStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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) { - this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; - this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4; + std::vector releaseExpectedParams{}; - 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->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED; + this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4; - auto image = std::unique_ptr(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 0, nullptr)); - ASSERT_NE(nullptr, image.get()); - auto d3dTexture = static_cast *>(image->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dTexture); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; - EXPECT_TRUE(d3dTexture->isSharedResource()); - EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging()); + auto image = std::unique_ptr(D3DTexture::create3d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, nullptr)); + ASSERT_NE(nullptr, image.get()); + auto d3dTexture = static_cast *>(image->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dTexture); - EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture)) - .Times(1); - EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery())) - .Times(1); + EXPECT_TRUE(d3dTexture->isSharedResource()); + EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTexture)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DTexture), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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) { - this->mockSharingFcns->mockTexture3dDesc.MiscFlags = 0; + std::vector releaseExpectedParams{}; - 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->mockTexture3dDesc.MiscFlags = 0; - auto image = std::unique_ptr(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); - ASSERT_NE(nullptr, image.get()); - auto d3dTexture = static_cast *>(image->getSharingHandler().get()); - ASSERT_NE(nullptr, d3dTexture); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; - EXPECT_FALSE(d3dTexture->isSharedResource()); - EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging()); + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&this->dummyD3DTextureStaging); - 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); + auto image = std::unique_ptr(D3DTexture::create3d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr)); + ASSERT_NE(nullptr, image.get()); + auto d3dTexture = static_cast *>(image->getSharingHandler().get()); + ASSERT_NE(nullptr, d3dTexture); + + EXPECT_FALSE(d3dTexture->isSharedResource()); + EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging()); + + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTextureStaging)); + releaseExpectedParams.push_back(reinterpret_cast(&this->dummyD3DTexture)); + releaseExpectedParams.push_back(reinterpret_cast(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(&this->dummyD3DTextureStaging), this->mockSharingFcns->getSharedHandleParamsPassed[0].resource); + EXPECT_EQ(reinterpret_cast(&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(D3DTexture::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + mockSharingFcns->createTexture2dSetParams = true; + mockSharingFcns->createTexture2dParamsSet.texture = reinterpret_cast(&this->dummyD3DTextureStaging); + + auto image = std::unique_ptr(D3DTexture::create2d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr)); ASSERT_NE(nullptr, image.get()); auto d3dTexture = static_cast *>(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(D3DTexture::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr)); + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&this->dummyD3DTextureStaging); + + auto image = std::unique_ptr(D3DTexture::create3d(this->context, reinterpret_cast(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr)); ASSERT_NE(nullptr, image.get()); auto d3dTexture = static_cast *>(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(D3DTexture::create2d(this->context, reinterpret_cast(&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(&this->dummyD3DTextureStaging))); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; + + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&this->dummyD3DTextureStaging); auto image = std::unique_ptr(D3DTexture::create3d(this->context, reinterpret_cast(&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(&this->dummyD3DTextureStaging))); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; + + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&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(&this->dummyD3DTextureStaging))); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; + + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&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(&this->dummyD3DTextureStaging))); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; + + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&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(&this->dummyD3DTextureStaging))); + this->mockSharingFcns->getTexture3dDescSetParams = true; + this->mockSharingFcns->getTexture3dDescParamsSet.textureDesc = this->mockSharingFcns->mockTexture3dDesc; + + this->mockSharingFcns->createTexture3dSetParams = true; + this->mockSharingFcns->createTexture3dParamsSet.texture = reinterpret_cast(&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 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(D3DTexture::create2d(this->context, reinterpret_cast(&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(D3DTexture::create3d(this->context, reinterpret_cast(&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, diff --git a/opencl/test/unit_test/fixtures/d3d_test_fixture.h b/opencl/test/unit_test/fixtures/d3d_test_fixture.h index 1d3465291e..910e1955fa 100644 --- a/opencl/test/unit_test/fixtures/d3d_test_fixture.h +++ b/opencl/test/unit_test/fixtures/d3d_test_fixture.h @@ -101,9 +101,9 @@ class D3DTests : public PlatformFixture, public ::testing::Test { context->preferD3dSharedResources = true; mockMM = std::make_unique(*context->getDevice(0)->getExecutionEnvironment()); - mockSharingFcns = new NiceMock>(); - 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(); + 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> *mockSharingFcns; + MockD3DSharingFunctions *mockSharingFcns; MockContext *context; MockCommandQueue *cmdQ; char dummyD3DBuffer; diff --git a/opencl/test/unit_test/mocks/mock_d3d_objects.h b/opencl/test/unit_test/mocks/mock_d3d_objects.h index e62e73a858..03e9b6ebf4 100644 --- a/opencl/test/unit_test/mocks/mock_d3d_objects.h +++ b/opencl/test/unit_test/mocks/mock_d3d_objects.h @@ -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 @@ -36,29 +35,286 @@ class MockD3DSharingFunctions : public D3DSharingFunctions { 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 getSharedHandleParamsPassed{}; + + void addRef(D3DResource *resource) override { + addRefCalled++; + addRefParamsPassed.push_back({resource}); + } + + struct AddRefParams { + D3DResource *resource{}; + }; + + uint32_t addRefCalled = 0u; + StackVec addRefParamsPassed{}; + + void release(IUnknown *resource) override { + releaseCalled++; + releaseParamsPassed.push_back({resource}); + } + + struct ReleaseParams { + IUnknown *resource{}; + }; + + uint32_t releaseCalled = 0u; + StackVec 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 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 lockRectParamsPassed{}; + + void unlockRect(D3DTexture2d *d3dResource) override { + unlockRectCalled++; + unlockRectParamsPassed.push_back({d3dResource}); + } + + struct UnlockRectParams { + D3DTexture2d *d3dResource{}; + }; + + uint32_t unlockRectCalled = 0u; + StackVec 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 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 updateSurfaceParamsPassed{}; + + void updateDevice(D3DResource *resource) override { + updateDeviceCalled++; + updateDeviceParamsPassed.push_back({resource}); + } + + struct UpdateDeviceParams { + D3DResource *resource{}; + }; + + uint32_t updateDeviceCalled = 0u; + StackVec 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 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::validateFormatSupport(format, type); @@ -78,5 +334,11 @@ class MockD3DSharingFunctions : public D3DSharingFunctions { 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