1 /*
2  * Copyright (C) 2019-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #include "shared/source/memory_manager/os_agnostic_memory_manager.h"
9 #include "shared/source/os_interface/os_interface.h"
10 #include "shared/source/utilities/arrayref.h"
11 #include "shared/test/common/helpers/debug_manager_state_restore.h"
12 #include "shared/test/common/mocks/mock_wddm.h"
13 
14 #include "opencl/source/api/api.h"
15 #include "opencl/source/mem_obj/image.h"
16 #include "opencl/source/platform/platform.h"
17 #include "opencl/source/sharings/d3d/cl_d3d_api.h"
18 #include "opencl/source/sharings/d3d/d3d_buffer.h"
19 #include "opencl/source/sharings/d3d/d3d_sharing.h"
20 #include "opencl/source/sharings/d3d/d3d_surface.h"
21 #include "opencl/source/sharings/d3d/d3d_texture.h"
22 #include "opencl/test/unit_test/fixtures/d3d_test_fixture.h"
23 
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26 
27 namespace NEO {
28 TYPED_TEST_CASE_P(D3DTests);
29 
TYPED_TEST_P(D3DTests,givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish)30 TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish) {
31     this->context->setInteropUserSyncEnabled(true);
32     this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
33 
34     EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
35         .Times(1)
36         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
37 
38     class MockCmdQ : public MockCommandQueue {
39       public:
40         MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
41         cl_int finish() override {
42             finishCalled++;
43             return CL_SUCCESS;
44         }
45         uint32_t finishCalled = 0;
46     };
47 
48     auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
49 
50     auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
51     ASSERT_NE(nullptr, buffer.get());
52     cl_mem bufferMem = (cl_mem)buffer.get();
53 
54     auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
55     EXPECT_EQ(CL_SUCCESS, retVal);
56     EXPECT_EQ(0u, mockCmdQ->finishCalled);
57 
58     retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
59     EXPECT_EQ(CL_SUCCESS, retVal);
60     EXPECT_EQ(0u, mockCmdQ->finishCalled);
61 }
62 
TYPED_TEST_P(D3DTests,givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice)63 TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice) {
64     this->context->setInteropUserSyncEnabled(false);
65 
66     class MockCmdQ : public MockCommandQueue {
67       public:
68         MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
69         cl_int finish() override {
70             finishCalled++;
71             return CL_SUCCESS;
72         }
73         uint32_t finishCalled = 0;
74     };
75 
76     auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
77 
78     auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
79     ASSERT_NE(nullptr, buffer.get());
80     cl_mem bufferMem = (cl_mem)buffer.get();
81 
82     auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
83     EXPECT_EQ(CL_SUCCESS, retVal);
84     EXPECT_EQ(0u, mockCmdQ->finishCalled);
85 
86     retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
87     EXPECT_EQ(CL_SUCCESS, retVal);
88     EXPECT_EQ(2u, mockCmdQ->finishCalled);
89 }
90 
TYPED_TEST_P(D3DTests,givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce)91 TYPED_TEST_P(D3DTests, givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce) {
92     this->context->setInteropUserSyncEnabled(false);
93     this->mockSharingFcns->mockBufferDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
94 
95     EXPECT_CALL(*this->mockSharingFcns, getBufferDesc(_, _))
96         .Times(1)
97         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockBufferDesc));
98 
99     class MockCmdQ : public MockCommandQueue {
100       public:
101         MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
102         cl_int finish() override {
103             finishCalled++;
104             return CL_SUCCESS;
105         }
106         uint32_t finishCalled = 0;
107     };
108 
109     auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
110 
111     auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
112     ASSERT_NE(nullptr, buffer.get());
113     cl_mem bufferMem = (cl_mem)buffer.get();
114 
115     auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
116     EXPECT_EQ(CL_SUCCESS, retVal);
117     EXPECT_EQ(0u, mockCmdQ->finishCalled);
118 
119     retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
120     EXPECT_EQ(CL_SUCCESS, retVal);
121     EXPECT_EQ(1u, mockCmdQ->finishCalled);
122 }
123 
TYPED_TEST_P(D3DTests,givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce)124 TYPED_TEST_P(D3DTests, givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce) {
125     this->context->setInteropUserSyncEnabled(true);
126 
127     class MockCmdQ : public MockCommandQueue {
128       public:
129         MockCmdQ(Context *context, ClDevice *device, const cl_queue_properties *properties) : MockCommandQueue(context, device, properties, false){};
130         cl_int finish() override {
131             finishCalled++;
132             return CL_SUCCESS;
133         }
134         uint32_t finishCalled = 0;
135     };
136 
137     auto mockCmdQ = std::unique_ptr<MockCmdQ>(new MockCmdQ(this->context, this->context->getDevice(0), 0));
138 
139     auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
140     ASSERT_NE(nullptr, buffer.get());
141     cl_mem bufferMem = (cl_mem)buffer.get();
142 
143     auto retVal = this->enqueueAcquireD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
144     EXPECT_EQ(CL_SUCCESS, retVal);
145     EXPECT_EQ(0u, mockCmdQ->finishCalled);
146 
147     retVal = this->enqueueReleaseD3DObjectsApi(this->mockSharingFcns, mockCmdQ.get(), 1, &bufferMem, 0, nullptr, nullptr);
148     EXPECT_EQ(CL_SUCCESS, retVal);
149     EXPECT_EQ(1u, mockCmdQ->finishCalled);
150 }
151 
TYPED_TEST_P(D3DTests,givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture)152 TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture) {
153     this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
154     this->mockSharingFcns->mockTexture2dDesc.ArraySize = 4;
155     this->mockSharingFcns->mockTexture2dDesc.MipLevels = 4;
156 
157     ::testing::InSequence is;
158     EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
159         .Times(1)
160         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
161     EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
162         .Times(0);
163     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
164         .Times(1);
165     EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
166         .Times(1);
167 
168     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 4, nullptr));
169     ASSERT_NE(nullptr, image.get());
170     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
171     ASSERT_NE(nullptr, d3dTexture);
172 
173     EXPECT_TRUE(d3dTexture->isSharedResource());
174     EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
175 
176     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
177         .Times(1);
178     EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
179         .Times(1);
180 }
181 
TYPED_TEST_P(D3DTests,givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture)182 TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture) {
183     this->mockSharingFcns->mockTexture2dDesc.MiscFlags = 0;
184 
185     ::testing::InSequence is;
186     EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
187         .Times(1)
188         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
189     EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
190         .Times(1)
191         .WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
192     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
193         .Times(1);
194     EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture2d *)&this->dummyD3DTexture))
195         .Times(1);
196 
197     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
198     ASSERT_NE(nullptr, image.get());
199     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
200     ASSERT_NE(nullptr, d3dTexture);
201 
202     EXPECT_FALSE(d3dTexture->isSharedResource());
203     EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
204 
205     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
206         .Times(1);
207     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
208         .Times(1);
209     EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
210         .Times(1);
211 }
212 
TYPED_TEST_P(D3DTests,givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture)213 TYPED_TEST_P(D3DTests, givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture) {
214     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
215     this->mockSharingFcns->mockTexture3dDesc.MipLevels = 4;
216 
217     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
218         .Times(1)
219         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
220     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
221         .Times(0);
222     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTexture, _))
223         .Times(1);
224     EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
225         .Times(1);
226 
227     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 0, nullptr));
228     ASSERT_NE(nullptr, image.get());
229     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
230     ASSERT_NE(nullptr, d3dTexture);
231 
232     EXPECT_TRUE(d3dTexture->isSharedResource());
233     EXPECT_EQ(&this->dummyD3DTexture, d3dTexture->getResourceStaging());
234 
235     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
236         .Times(1);
237     EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
238         .Times(1);
239 }
240 
TYPED_TEST_P(D3DTests,givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture)241 TYPED_TEST_P(D3DTests, givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture) {
242     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = 0;
243 
244     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
245         .Times(1)
246         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
247     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
248         .Times(1)
249         .WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
250     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle((D3DTexture2d *)&this->dummyD3DTextureStaging, _))
251         .Times(1);
252     EXPECT_CALL(*this->mockSharingFcns, addRef((D3DTexture3d *)&this->dummyD3DTexture))
253         .Times(1);
254 
255     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
256     ASSERT_NE(nullptr, image.get());
257     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
258     ASSERT_NE(nullptr, d3dTexture);
259 
260     EXPECT_FALSE(d3dTexture->isSharedResource());
261     EXPECT_EQ(&this->dummyD3DTextureStaging, d3dTexture->getResourceStaging());
262 
263     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTextureStaging))
264         .Times(1);
265     EXPECT_CALL(*this->mockSharingFcns, release((D3DTexture2d *)&this->dummyD3DTexture))
266         .Times(1);
267     EXPECT_CALL(*this->mockSharingFcns, release((D3DQuery *)d3dTexture->getQuery()))
268         .Times(1);
269 }
270 
TYPED_TEST_P(D3DTests,givenD3DDeviceParamWhenContextCreationThenSetProperValues)271 TYPED_TEST_P(D3DTests, givenD3DDeviceParamWhenContextCreationThenSetProperValues) {
272     cl_device_id deviceID = this->context->getDevice(0);
273     cl_platform_id pid[1] = {this->pPlatform};
274     auto param = this->pickParam(CL_CONTEXT_D3D10_DEVICE_KHR, CL_CONTEXT_D3D11_DEVICE_KHR);
275 
276     cl_context_properties validProperties[5] = {CL_CONTEXT_PLATFORM, (cl_context_properties)pid[0], param, 0, 0};
277     cl_int retVal = CL_SUCCESS;
278     auto ctx = std::unique_ptr<MockContext>(Context::create<MockContext>(validProperties, ClDeviceVector(&deviceID, 1), nullptr, nullptr, retVal));
279 
280     EXPECT_EQ(CL_SUCCESS, retVal);
281     ASSERT_NE(nullptr, ctx.get());
282     EXPECT_EQ(1u, ctx->preferD3dSharedResources);
283     EXPECT_NE(nullptr, ctx->getSharing<D3DSharingFunctions<TypeParam>>());
284 }
285 
TYPED_TEST_P(D3DTests,givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle)286 TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle) {
287     this->mockSharingFcns->mockTexture2dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
288 
289     EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
290         .Times(1)
291         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
292     EXPECT_CALL(*this->mockSharingFcns, createTexture2d(_, _, _))
293         .Times(1)
294         .WillOnce(SetArgPointee<0>((D3DTexture2d *)&this->dummyD3DTextureStaging));
295     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
296         .Times(0);
297     EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
298         .Times(1);
299 
300     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, (D3DTexture2d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
301     ASSERT_NE(nullptr, image.get());
302     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
303     ASSERT_NE(nullptr, d3dTexture);
304 }
305 
TYPED_TEST_P(D3DTests,givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle)306 TYPED_TEST_P(D3DTests, givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle) {
307     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
308 
309     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
310         .Times(1)
311         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
312     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
313         .Times(1)
314         .WillOnce(SetArgPointee<0>((D3DTexture3d *)&this->dummyD3DTextureStaging));
315     EXPECT_CALL(*this->mockSharingFcns, getSharedHandle(_, _))
316         .Times(0);
317     EXPECT_CALL(*this->mockSharingFcns, getSharedNTHandle(_, _))
318         .Times(1);
319 
320     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, (D3DTexture3d *)&this->dummyD3DTexture, CL_MEM_READ_WRITE, 1, nullptr));
321     ASSERT_NE(nullptr, image.get());
322     auto d3dTexture = static_cast<D3DTexture<TypeParam> *>(image->getSharingHandler().get());
323     ASSERT_NE(nullptr, d3dTexture);
324 }
325 
TYPED_TEST_P(D3DTests,WhenFillingBufferDescThenBufferContentIsCorrect)326 TYPED_TEST_P(D3DTests, WhenFillingBufferDescThenBufferContentIsCorrect) {
327     D3DBufferDesc requestedDesc = {};
328     D3DBufferDesc expectedDesc = {};
329     expectedDesc.ByteWidth = 10;
330     expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
331 
332     this->mockSharingFcns->fillCreateBufferDesc(requestedDesc, 10);
333     EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DBufferDesc)) == 0);
334 }
335 
TYPED_TEST_P(D3DTests,WhenFillingTexture2dDescThenImageContentIsCorrect)336 TYPED_TEST_P(D3DTests, WhenFillingTexture2dDescThenImageContentIsCorrect) {
337     D3DTexture2dDesc requestedDesc = {};
338     D3DTexture2dDesc expectedDesc = {};
339     D3DTexture2dDesc srcDesc = {};
340     cl_uint subresource = 4;
341 
342     srcDesc.Width = 10;
343     srcDesc.Height = 20;
344     srcDesc.MipLevels = 9;
345     srcDesc.ArraySize = 5;
346     srcDesc.Format = DXGI_FORMAT::DXGI_FORMAT_A8_UNORM;
347     srcDesc.SampleDesc = {8, 9};
348     srcDesc.BindFlags = 123;
349     srcDesc.CPUAccessFlags = 456;
350     srcDesc.MiscFlags = 789;
351 
352     expectedDesc.Width = srcDesc.Width;
353     expectedDesc.Height = srcDesc.Height;
354     expectedDesc.MipLevels = 1;
355     expectedDesc.ArraySize = 1;
356     expectedDesc.Format = srcDesc.Format;
357     expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
358     expectedDesc.SampleDesc = srcDesc.SampleDesc;
359 
360     for (uint32_t i = 0u; i < (subresource % srcDesc.MipLevels); i++) {
361         expectedDesc.Width /= 2;
362         expectedDesc.Height /= 2;
363     }
364 
365     this->mockSharingFcns->fillCreateTexture2dDesc(requestedDesc, &srcDesc, subresource);
366     EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DTexture2dDesc)) == 0);
367 }
368 
TYPED_TEST_P(D3DTests,WhenFillingTexture3dDescThenImageContentIsCorrect)369 TYPED_TEST_P(D3DTests, WhenFillingTexture3dDescThenImageContentIsCorrect) {
370     D3DTexture3dDesc requestedDesc = {};
371     D3DTexture3dDesc expectedDesc = {};
372     D3DTexture3dDesc srcDesc = {};
373     cl_uint subresource = 4;
374 
375     srcDesc.Width = 10;
376     srcDesc.Height = 20;
377     srcDesc.Depth = 30;
378     srcDesc.MipLevels = 9;
379     srcDesc.Format = DXGI_FORMAT::DXGI_FORMAT_A8_UNORM;
380     srcDesc.BindFlags = 123;
381     srcDesc.CPUAccessFlags = 456;
382     srcDesc.MiscFlags = 789;
383 
384     expectedDesc.Width = srcDesc.Width;
385     expectedDesc.Height = srcDesc.Height;
386     expectedDesc.Depth = srcDesc.Depth;
387     expectedDesc.MipLevels = 1;
388     expectedDesc.Format = srcDesc.Format;
389     expectedDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
390 
391     for (uint32_t i = 0u; i < (subresource % srcDesc.MipLevels); i++) {
392         expectedDesc.Width /= 2;
393         expectedDesc.Height /= 2;
394         expectedDesc.Depth /= 2;
395     }
396 
397     this->mockSharingFcns->fillCreateTexture3dDesc(requestedDesc, &srcDesc, subresource);
398     EXPECT_TRUE(memcmp(&requestedDesc, &expectedDesc, sizeof(D3DTexture3dDesc)) == 0);
399 }
400 
TYPED_TEST_P(D3DTests,givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat)401 TYPED_TEST_P(D3DTests, givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat) {
402     const ClSurfaceFormatInfo *surfaceFormat;
403     DXGI_FORMAT testFormat[] = {DXGI_FORMAT::DXGI_FORMAT_NV12, DXGI_FORMAT::DXGI_FORMAT_P010, DXGI_FORMAT::DXGI_FORMAT_P016};
404     int channelDataType[] = {CL_UNORM_INT8, CL_UNORM_INT16, CL_UNORM_INT16};
405     for (int n = 0; n < 3; n++) {
406         surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::NO_PLANE, CL_MEM_READ_WRITE);
407         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
408         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
409 
410         surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_U, CL_MEM_READ_WRITE);
411         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
412         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
413 
414         surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_UV, CL_MEM_READ_WRITE);
415         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
416         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
417 
418         surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_V, CL_MEM_READ_WRITE);
419         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_RG);
420         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
421 
422         surfaceFormat = D3DTexture<TypeParam>::findYuvSurfaceFormatInfo(testFormat[n], ImagePlane::PLANE_Y, CL_MEM_READ_WRITE);
423         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_order == CL_R);
424         EXPECT_TRUE(surfaceFormat->OCLImageFormat.image_channel_data_type == channelDataType[n]);
425     }
426 }
427 
TYPED_TEST_P(D3DTests,GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation)428 TYPED_TEST_P(D3DTests, GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation) {
429 
430     auto buffer = std::unique_ptr<Buffer>(D3DBuffer<TypeParam>::create(this->context, (D3DBufferObj *)&this->dummyD3DBuffer, CL_MEM_READ_WRITE, nullptr));
431     ASSERT_NE(nullptr, buffer.get());
432 
433     auto *allocation = buffer->getGraphicsAllocation(rootDeviceIndex);
434     EXPECT_NE(nullptr, allocation);
435 
436     EXPECT_TRUE(allocation->is32BitAllocation());
437 }
438 
TYPED_TEST_P(D3DTests,givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet)439 TYPED_TEST_P(D3DTests, givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
440     this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_P016;
441     EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
442         .Times(1)
443         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
444 
445     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 7, nullptr));
446     ASSERT_NE(nullptr, image.get());
447     ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
448     EXPECT_EQ(GraphicsAllocation::AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
449 }
450 
TYPED_TEST_P(D3DTests,givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet)451 TYPED_TEST_P(D3DTests, givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet) {
452     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
453 
454     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
455         .Times(1)
456         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
457     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
458         .Times(1)
459         .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
460 
461     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, nullptr));
462     ASSERT_NE(nullptr, image.get());
463     ASSERT_NE(nullptr, image->getGraphicsAllocation(rootDeviceIndex));
464     EXPECT_EQ(GraphicsAllocation::AllocationType::SHARED_IMAGE, image->getGraphicsAllocation(rootDeviceIndex)->getAllocationType());
465 }
466 
TYPED_TEST_P(D3DTests,givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode)467 TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode) {
468     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
469 
470     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
471         .Times(1)
472         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
473     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
474         .Times(1)
475         .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
476 
477     cl_int retCode = 0;
478     mockMM.get()->verifyValue = false;
479     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
480     mockMM.get()->verifyValue = true;
481     EXPECT_EQ(nullptr, image.get());
482     EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
483 }
484 
TYPED_TEST_P(D3DTests,givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode)485 TYPED_TEST_P(D3DTests, givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode) {
486     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
487 
488     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
489         .Times(1)
490         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
491     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
492         .Times(1)
493         .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
494 
495     cl_int retCode = 0;
496     mockMM.get()->verifyValue = false;
497     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
498     mockMM.get()->verifyValue = true;
499     EXPECT_EQ(nullptr, image.get());
500     EXPECT_EQ(retCode, CL_INVALID_D3D11_RESOURCE_KHR);
501 }
502 
TYPED_TEST_P(D3DTests,givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode)503 TYPED_TEST_P(D3DTests, givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode) {
504     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED;
505 
506     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
507         .Times(1)
508         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
509     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
510         .Times(1)
511         .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
512 
513     cl_int retCode = 0;
514     mockMM.get()->failAlloc = true;
515     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
516     mockMM.get()->failAlloc = false;
517     EXPECT_EQ(nullptr, image.get());
518     EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
519 }
520 
TYPED_TEST_P(D3DTests,givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode)521 TYPED_TEST_P(D3DTests, givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode) {
522     this->mockSharingFcns->mockTexture3dDesc.MiscFlags = D3DResourceFlags::MISC_SHARED_NTHANDLE;
523 
524     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
525         .Times(1)
526         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
527     EXPECT_CALL(*this->mockSharingFcns, createTexture3d(_, _, _))
528         .Times(1)
529         .WillOnce(SetArgPointee<0>(reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTextureStaging)));
530 
531     cl_int retCode = 0;
532     mockMM.get()->failAlloc = true;
533     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 1, &retCode));
534     mockMM.get()->failAlloc = false;
535     EXPECT_EQ(nullptr, image.get());
536     EXPECT_EQ(retCode, CL_OUT_OF_HOST_MEMORY);
537 }
538 
TYPED_TEST_P(D3DTests,givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned)539 TYPED_TEST_P(D3DTests, givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned) {
540     std::vector<DXGI_FORMAT> unsupportedDXGIformats = {
541         DXGI_FORMAT_BC6H_TYPELESS,
542         DXGI_FORMAT_BC6H_UF16,
543         DXGI_FORMAT_BC6H_SF16,
544         DXGI_FORMAT_BC7_TYPELESS,
545         DXGI_FORMAT_BC7_UNORM,
546         DXGI_FORMAT_BC7_UNORM_SRGB,
547         DXGI_FORMAT_AYUV,
548         DXGI_FORMAT_Y410,
549         DXGI_FORMAT_Y416,
550         DXGI_FORMAT_420_OPAQUE,
551         DXGI_FORMAT_YUY2,
552         DXGI_FORMAT_Y210,
553         DXGI_FORMAT_Y216,
554         DXGI_FORMAT_NV11,
555         DXGI_FORMAT_AI44,
556         DXGI_FORMAT_IA44,
557         DXGI_FORMAT_P8,
558         DXGI_FORMAT_A8P8,
559         DXGI_FORMAT_B4G4R4A4_UNORM,
560         DXGI_FORMAT_P208,
561         DXGI_FORMAT_V208,
562         DXGI_FORMAT_V408,
563         DXGI_FORMAT_FORCE_UINT};
564 
565     auto checkFormat = [&](DXGI_FORMAT format, UINT *pFormat) -> bool {
566         auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
567         if (iter != unsupportedDXGIformats.end()) {
568             return false;
569         }
570         *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
571         return true;
572     };
573 
574     ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
575     ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
576 
577     std::vector<DXGI_FORMAT> formats;
578     cl_uint numTextureFormats = 0;
579     auto retVal = getSupportedDXTextureFormats<TypeParam>(context, CL_MEM_OBJECT_IMAGE3D, 0, 0, nullptr, &numTextureFormats);
580     EXPECT_EQ(CL_SUCCESS, retVal);
581     EXPECT_NE(0u, numTextureFormats);
582 
583     formats.resize(numTextureFormats);
584     retVal = getSupportedDXTextureFormats<TypeParam>(context, CL_MEM_OBJECT_IMAGE3D, 0, static_cast<cl_uint>(formats.size()), formats.data(), &numTextureFormats);
585 
586     EXPECT_EQ(CL_SUCCESS, retVal);
587 
588     bool foundUnsupported = false;
589     for (auto format : formats) {
590         auto iter = std::find(unsupportedDXGIformats.begin(), unsupportedDXGIformats.end(), format);
591         if (iter != unsupportedDXGIformats.end()) {
592             foundUnsupported = true;
593         }
594     }
595     EXPECT_FALSE(foundUnsupported);
596 }
597 
TYPED_TEST_P(D3DTests,givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned)598 TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned) {
599 
600     auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
601         if (format == DXGI_FORMAT_R32_FLOAT) {
602             return false;
603         }
604         *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
605         return true;
606     };
607 
608     auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
609         return mockSharingFcns->validateFormatSupportBase(format, type);
610     };
611 
612     ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
613     ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
614 
615     ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
616         .WillByDefault(::testing::Invoke(validate));
617 
618     this->mockSharingFcns->mockTexture2dDesc.Format = DXGI_FORMAT_R32_FLOAT;
619 
620     EXPECT_CALL(*this->mockSharingFcns, getTexture2dDesc(_, _))
621         .Times(1)
622         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture2dDesc));
623 
624     cl_int retCode = CL_SUCCESS;
625     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create2d(this->context, reinterpret_cast<D3DTexture2d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
626     EXPECT_EQ(nullptr, image.get());
627 
628     EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
629 }
630 
TYPED_TEST_P(D3DTests,givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned)631 TYPED_TEST_P(D3DTests, givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned) {
632 
633     auto checkFormat = [](DXGI_FORMAT format, UINT *pFormat) -> bool {
634         if (format == DXGI_FORMAT_R32_FLOAT) {
635             return false;
636         }
637         *pFormat = D3D11_FORMAT_SUPPORT_BUFFER | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D;
638         return true;
639     };
640 
641     auto validate = [&](DXGI_FORMAT format, cl_mem_object_type type) -> cl_int {
642         return mockSharingFcns->validateFormatSupportBase(format, type);
643     };
644 
645     ON_CALL(*mockSharingFcns, checkFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Invoke(checkFormat));
646     ON_CALL(*mockSharingFcns, memObjectFormatSupport(::testing::_, ::testing::_)).WillByDefault(::testing::Return(true));
647 
648     ON_CALL(*mockSharingFcns, validateFormatSupport(::testing::_, ::testing::_))
649         .WillByDefault(::testing::Invoke(validate));
650 
651     this->mockSharingFcns->mockTexture3dDesc.Format = DXGI_FORMAT_R32_FLOAT;
652 
653     EXPECT_CALL(*this->mockSharingFcns, getTexture3dDesc(_, _))
654         .Times(1)
655         .WillOnce(SetArgPointee<0>(this->mockSharingFcns->mockTexture3dDesc));
656 
657     cl_int retCode = CL_SUCCESS;
658     auto image = std::unique_ptr<Image>(D3DTexture<TypeParam>::create3d(this->context, reinterpret_cast<D3DTexture3d *>(&this->dummyD3DTexture), CL_MEM_READ_WRITE, 0, &retCode));
659     EXPECT_EQ(nullptr, image.get());
660 
661     EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retCode);
662 }
663 
664 REGISTER_TYPED_TEST_CASE_P(D3DTests,
665                            givenSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDontDoExplicitFinish,
666                            givenNonSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishTwice,
667                            givenSharedResourceBufferAndInteropUserSyncDisabledWhenReleaseIsCalledThenDoExplicitFinishOnce,
668                            givenNonSharedResourceBufferAndInteropUserSyncEnabledWhenReleaseIsCalledThenDoExplicitFinishOnce,
669                            givenSharedResourceFlagWhenCreate2dTextureThenStagingTextureEqualsPassedTexture,
670                            givenNonSharedResourceFlagWhenCreate2dTextureThenCreateStagingTexture,
671                            givenSharedResourceFlagWhenCreate3dTextureThenStagingTextureEqualsPassedTexture,
672                            givenNonSharedResourceFlagWhenCreate3dTextureThenCreateStagingTexture,
673                            givenD3DDeviceParamWhenContextCreationThenSetProperValues,
674                            givenSharedNtHandleFlagWhenCreate2dTextureThenGetNtHandle,
675                            givenSharedNtHandleFlagWhenCreate3dTextureThenGetNtHandle,
676                            WhenFillingBufferDescThenBufferContentIsCorrect,
677                            WhenFillingTexture2dDescThenImageContentIsCorrect,
678                            WhenFillingTexture3dDescThenImageContentIsCorrect,
679                            givenPlaneWhenFindYuvSurfaceCalledThenReturnValidImgFormat,
680                            GivenForced32BitAddressingWhenCreatingBufferThenBufferHas32BitAllocation,
681                            givenD3DTexture2dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet,
682                            givenD3DTexture3dWhenOclImageIsCreatedThenSharedImageAllocationTypeIsSet,
683                            givenSharedObjectFromInvalidContextWhen3dCreatedThenReturnCorrectCode,
684                            givenSharedObjectFromInvalidContextAndNTHandleWhen3dCreatedThenReturnCorrectCode,
685                            givenSharedObjectAndAlocationFailedWhen3dCreatedThenReturnCorrectCode,
686                            givenSharedObjectAndNTHandleAndAllocationFailedWhen3dCreatedThenReturnCorrectCode,
687                            givenFormatNotSupportedByDxWhenGettingSupportedFormatsThenOnlySupportedFormatsAreReturned,
688                            givenUnsupportedFormatWhenCreatingTexture2dThenInvalidImageFormatDescriptorIsReturned,
689                            givenUnsupportedFormatWhenCreatingTexture3dThenInvalidImageFormatDescriptorIsReturned);
690 
691 INSTANTIATE_TYPED_TEST_CASE_P(D3DSharingTests, D3DTests, D3DTypes);
692 
693 using D3D10Test = D3DTests<D3DTypesHelper::D3D10>;
694 
TEST_F(D3D10Test,givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned)695 TEST_F(D3D10Test, givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned) {
696     cl_device_id deviceID;
697     cl_uint numDevices = 15;
698     static_cast<WddmMock *>(context->getDevice(0)->getRootDeviceEnvironment().osInterface->getDriverModel()->as<Wddm>())->verifyAdapterLuidReturnValue = false;
699 
700     auto retVal = clGetDeviceIDsFromD3D10KHR(pPlatform, CL_D3D10_DEVICE_KHR, nullptr, CL_ALL_DEVICES_FOR_D3D10_KHR, 1, &deviceID, &numDevices);
701 
702     EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
703     EXPECT_EQ(0, numDevices);
704 }
705 
706 using D3D11Test = D3DTests<D3DTypesHelper::D3D11>;
707 
TEST_F(D3D11Test,givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned)708 TEST_F(D3D11Test, givenIncompatibleAdapterLuidWhenGettingDeviceIdsThenNoDevicesAreReturned) {
709     cl_device_id deviceID;
710     cl_uint numDevices = 15;
711     static_cast<WddmMock *>(context->getDevice(0)->getRootDeviceEnvironment().osInterface->getDriverModel()->as<Wddm>())->verifyAdapterLuidReturnValue = false;
712 
713     auto retVal = clGetDeviceIDsFromD3D11KHR(pPlatform, CL_D3D11_DEVICE_KHR, nullptr, CL_ALL_DEVICES_FOR_D3D11_KHR, 1, &deviceID, &numDevices);
714 
715     EXPECT_EQ(CL_DEVICE_NOT_FOUND, retVal);
716     EXPECT_EQ(0, numDevices);
717 }
718 
TEST(D3D11,GivenPlanarFormatsWhenCallingIsFormatWithPlane1ThenTrueIsReturned)719 TEST(D3D11, GivenPlanarFormatsWhenCallingIsFormatWithPlane1ThenTrueIsReturned) {
720     std::array<DXGI_FORMAT, 6> planarFormats = {DXGI_FORMAT_NV12, DXGI_FORMAT_P010, DXGI_FORMAT_P016,
721                                                 DXGI_FORMAT_420_OPAQUE, DXGI_FORMAT_NV11, DXGI_FORMAT_P208};
722 
723     for (auto format : planarFormats) {
724         EXPECT_TRUE(D3DSharing<D3DTypesHelper::D3D11>::isFormatWithPlane1(format));
725     }
726 }
727 
TEST(D3D11,GivenNonPlanarFormatsWhenCallingIsFormatWithPlane1ThenFalseIsReturned)728 TEST(D3D11, GivenNonPlanarFormatsWhenCallingIsFormatWithPlane1ThenFalseIsReturned) {
729     std::array<DXGI_FORMAT, 6> planarFormats = {DXGI_FORMAT_R32G32B32_FLOAT,
730                                                 DXGI_FORMAT_R32G32B32_UINT,
731                                                 DXGI_FORMAT_R32G32B32_SINT};
732 
733     for (auto format : planarFormats) {
734         EXPECT_FALSE(D3DSharing<D3DTypesHelper::D3D11>::isFormatWithPlane1(format));
735     }
736 }
737 
738 } // namespace NEO
739