1 /*
2 * Copyright (C) 2018-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/execution_environment/root_device_environment.h"
9 #include "shared/source/helpers/timestamp_packet.h"
10 #include "shared/source/os_interface/os_interface.h"
11 #include "shared/source/os_interface/windows/os_context_win.h"
12 #include "shared/source/os_interface/windows/wddm/wddm.h"
13 #include "shared/source/os_interface/windows/wddm_memory_operations_handler.h"
14 #include "shared/test/common/helpers/engine_descriptor_helper.h"
15 #include "shared/test/common/mocks/mock_execution_environment.h"
16 #include "shared/test/common/os_interface/windows/mock_sys_calls.h"
17 #include "shared/test/common/os_interface/windows/wddm_fixture.h"
18
19 #include "opencl/extensions/public/cl_gl_private_intel.h"
20 #include "opencl/source/sharings/gl/gl_arb_sync_event.h"
21 #include "opencl/source/sharings/gl/windows/gl_sharing_windows.h"
22 #include "opencl/test/unit_test/mocks/gl/windows/mock_gl_sharing_windows.h"
23 #include "opencl/test/unit_test/mocks/mock_platform.h"
24
25 #include "gtest/gtest.h"
26 #include <GL/gl.h>
27
28 using namespace NEO;
29
30 struct MockOSInterface : OSInterface {
createEventMockOSInterface31 static HANDLE createEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName, void *data) {
32 MockOSInterface *self = reinterpret_cast<MockOSInterface *>(data);
33 if (self->eventNum++ == self->failEventNum) {
34 return INVALID_HANDLE;
35 }
36 return handleValue;
37 }
closeHandleMockOSInterface38 static BOOL closeHandle(HANDLE hObject, void *data) {
39 MockOSInterface *self = reinterpret_cast<MockOSInterface *>(data);
40 ++self->closedEventsCount;
41 return (reinterpret_cast<HANDLE>(dummyHandle) == hObject) ? TRUE : FALSE;
42 }
43 int eventNum = 1;
44 int failEventNum = 0;
45 int closedEventsCount = 0;
46 };
47
TEST(glSharingBasicTest,GivenSharingFunctionsWhenItIsConstructedThenBackupContextIsCreated)48 TEST(glSharingBasicTest, GivenSharingFunctionsWhenItIsConstructedThenBackupContextIsCreated) {
49 GLType GLHDCType = CL_WGL_HDC_KHR;
50 GLContext GLHGLRCHandle = 0;
51 GLDisplay GLHDCHandle = 0;
52 int32_t expectedContextAttrs[3] = {0};
53 GlDllHelper dllHelper;
54
55 auto glSharingFunctions = new GlSharingFunctionsMock(GLHDCType, GLHGLRCHandle, GLHGLRCHandle, GLHDCHandle);
56
57 EXPECT_EQ(1, dllHelper.getParam("WGLCreateContextCalled"));
58 EXPECT_EQ(1, dllHelper.getParam("WGLShareListsCalled"));
59 EXPECT_EQ(0, EGLChooseConfigCalled);
60 EXPECT_EQ(0, EGLCreateContextCalled);
61 EXPECT_EQ(0, GlxChooseFBConfigCalled);
62 EXPECT_EQ(0, GlxQueryContextCalled);
63 EXPECT_EQ(0, GlxCreateNewContextCalled);
64 EXPECT_EQ(0, GlxIsDirectCalled);
65 EXPECT_EQ(0, eglBkpContextParams.configAttrs);
66 EXPECT_EQ(0, eglBkpContextParams.numConfigs);
67 EXPECT_TRUE(glSharingFunctions->getBackupContextHandle() != 0);
68 EXPECT_TRUE(memcmp(eglBkpContextParams.contextAttrs, expectedContextAttrs, 3 * sizeof(int32_t)) == 0);
69 EXPECT_EQ(0, glxBkpContextParams.FBConfigAttrs);
70 EXPECT_EQ(0, glxBkpContextParams.queryAttribute);
71 EXPECT_EQ(0, glxBkpContextParams.renderType);
72 delete glSharingFunctions;
73 EXPECT_EQ(1, dllHelper.getParam("WGLDeleteContextCalled"));
74 EXPECT_EQ(1, dllHelper.getParam("GLDeleteContextCalled"));
75 }
76
77 struct GlArbSyncEventOsTest : public ::testing::Test {
SetUpGlArbSyncEventOsTest78 void SetUp() override {
79 rootDeviceEnvironment = std::make_unique<RootDeviceEnvironment>(executionEnvironment);
80 sharing.GLContextHandle = 0x2cU;
81 sharing.GLDeviceHandle = 0x3cU;
82 wddm = new WddmMock(*rootDeviceEnvironment);
83 rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
84 osInterface = rootDeviceEnvironment->osInterface.get();
85 osInterface->setDriverModel(std::unique_ptr<DriverModel>(wddm));
86 gdi = new MockGdi();
87 wddm->resetGdi(gdi);
88 }
89 MockExecutionEnvironment executionEnvironment;
90 std::unique_ptr<RootDeviceEnvironment> rootDeviceEnvironment;
91 GlSharingFunctionsMock sharing;
92 MockGdi *gdi = nullptr;
93 WddmMock *wddm = nullptr;
94 CL_GL_SYNC_INFO syncInfo = {};
95 OSInterface *osInterface = nullptr;
96 };
97
TEST_F(GlArbSyncEventOsTest,WhenCreateSynchronizationObjectSucceedsThenAllHAndlesAreValid)98 TEST_F(GlArbSyncEventOsTest, WhenCreateSynchronizationObjectSucceedsThenAllHAndlesAreValid) {
99 struct CreateSyncObjectMock {
100 static int &getHandle() {
101 static int handle = 1;
102 return handle;
103 }
104
105 static void reset() {
106 getHandle() = 1;
107 }
108
109 static NTSTATUS __stdcall createSynchObject(D3DKMT_CREATESYNCHRONIZATIONOBJECT *pData) {
110 if (pData == nullptr) {
111 return STATUS_INVALID_PARAMETER;
112 }
113
114 EXPECT_NE(NULL, pData->hDevice);
115 EXPECT_EQ(D3DDDI_SEMAPHORE, pData->Info.Type);
116
117 EXPECT_EQ(32, pData->Info.Semaphore.MaxCount);
118 EXPECT_EQ(0, pData->Info.Semaphore.InitialCount);
119
120 pData->hSyncObject = getHandle()++;
121 return STATUS_SUCCESS;
122 }
123
124 static NTSTATUS __stdcall createSynchObject2(D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *pData) {
125 if (pData == nullptr) {
126 return STATUS_INVALID_PARAMETER;
127 }
128
129 EXPECT_NE(NULL, pData->hDevice);
130 EXPECT_EQ(D3DDDI_CPU_NOTIFICATION, pData->Info.Type);
131 EXPECT_NE(nullptr, pData->Info.CPUNotification.Event);
132
133 pData->hSyncObject = getHandle()++;
134 return STATUS_SUCCESS;
135 }
136 };
137 CreateSyncObjectMock::reset();
138
139 wddm->init();
140 gdi->createSynchronizationObject.mFunc = CreateSyncObjectMock::createSynchObject;
141 gdi->createSynchronizationObject2.mFunc = CreateSyncObjectMock::createSynchObject2;
142 auto ret = setupArbSyncObject(sharing, *osInterface, syncInfo);
143 EXPECT_TRUE(ret);
144 EXPECT_EQ(1U, syncInfo.serverSynchronizationObject);
145 EXPECT_EQ(2U, syncInfo.clientSynchronizationObject);
146 EXPECT_EQ(3U, syncInfo.submissionSynchronizationObject);
147 EXPECT_EQ(sharing.GLContextHandle, syncInfo.hContextToBlock);
148 EXPECT_NE(nullptr, syncInfo.event);
149 EXPECT_NE(nullptr, syncInfo.eventName);
150 EXPECT_NE(nullptr, syncInfo.submissionEvent);
151 EXPECT_NE(nullptr, syncInfo.submissionEventName);
152 EXPECT_FALSE(syncInfo.waitCalled);
153 cleanupArbSyncObject(*osInterface, &syncInfo);
154 }
155
TEST_F(GlArbSyncEventOsTest,GivenNewGlSyncInfoWhenCreateSynchronizationObjectFailsThenSetupArbSyncObjectFails)156 TEST_F(GlArbSyncEventOsTest, GivenNewGlSyncInfoWhenCreateSynchronizationObjectFailsThenSetupArbSyncObjectFails) {
157 struct CreateSyncObjectMock {
158 static int &getHandle() {
159 static int handle = 1;
160 return handle;
161 }
162
163 static int &getFailHandleId() {
164 static int failHandleId = 0;
165 return failHandleId;
166 }
167
168 static void reset() {
169 getHandle() = 1;
170 getFailHandleId() = 0;
171 }
172
173 static NTSTATUS __stdcall createSynchObject(D3DKMT_CREATESYNCHRONIZATIONOBJECT *pData) {
174 auto newHandle = getHandle()++;
175 if (newHandle == getFailHandleId()) {
176 return STATUS_INVALID_PARAMETER;
177 }
178 return STATUS_SUCCESS;
179 }
180
181 static NTSTATUS __stdcall createSynchObject2(D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *pData) {
182 auto newHandle = getHandle()++;
183 if (newHandle == getFailHandleId()) {
184 return STATUS_INVALID_PARAMETER;
185 }
186 return STATUS_SUCCESS;
187 }
188 };
189 CreateSyncObjectMock::reset();
190 wddm->init();
191 gdi->createSynchronizationObject.mFunc = CreateSyncObjectMock::createSynchObject;
192 gdi->createSynchronizationObject2.mFunc = CreateSyncObjectMock::createSynchObject2;
193
194 CreateSyncObjectMock::getFailHandleId() = CreateSyncObjectMock::getHandle();
195 int failuresCount = 0;
196 auto ret = setupArbSyncObject(sharing, *osInterface, syncInfo);
197 while (false == ret) {
198 ++failuresCount;
199 CreateSyncObjectMock::getHandle() = 1;
200 ++CreateSyncObjectMock::getFailHandleId();
201 ret = setupArbSyncObject(sharing, *osInterface, syncInfo);
202 }
203 EXPECT_EQ(3, failuresCount);
204 cleanupArbSyncObject(*osInterface, &syncInfo);
205 }
206
TEST_F(GlArbSyncEventOsTest,GivenNewGlSyncInfoWhenCreateEventFailsThenSetupArbSyncObjectFails)207 TEST_F(GlArbSyncEventOsTest, GivenNewGlSyncInfoWhenCreateEventFailsThenSetupArbSyncObjectFails) {
208 auto rootDeviceEnvironment = platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0].get();
209 rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
210
211 MockOSInterface mockOsInterface;
212 auto createEventMock = changeSysCallMock(mockCreateEventClb, mockCreateEventClbData, MockOSInterface::createEvent, &mockOsInterface);
213
214 auto wddm = new WddmMock(*rootDeviceEnvironment);
215 auto gdi = new MockGdi();
216 wddm->resetGdi(gdi);
217 wddm->init();
218
219 mockOsInterface.setDriverModel(std::unique_ptr<DriverModel>(wddm));
220
221 mockOsInterface.failEventNum = mockOsInterface.eventNum;
222 int failuresCount = 0;
223 auto ret = setupArbSyncObject(sharing, mockOsInterface, syncInfo);
224 while (false == ret) {
225 ++failuresCount;
226 mockOsInterface.eventNum = 1;
227 ++mockOsInterface.failEventNum;
228 ret = setupArbSyncObject(sharing, mockOsInterface, syncInfo);
229 }
230 EXPECT_EQ(2, failuresCount);
231 cleanupArbSyncObject(mockOsInterface, &syncInfo);
232 }
233
TEST_F(GlArbSyncEventOsTest,GivenInvalidGlSyncInfoWhenCleanupArbSyncObjectIsCalledThenDestructorsOfSyncOrEventsAreNotInvoked)234 TEST_F(GlArbSyncEventOsTest, GivenInvalidGlSyncInfoWhenCleanupArbSyncObjectIsCalledThenDestructorsOfSyncOrEventsAreNotInvoked) {
235 struct DestroySyncObjectMock {
236 static NTSTATUS __stdcall destroySynchObject(_In_ CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *sync) {
237 EXPECT_FALSE(true);
238 return STATUS_INVALID_PARAMETER;
239 }
240 };
241 auto rootDeviceEnvironment = platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0].get();
242 rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
243
244 auto wddm = new WddmMock(*rootDeviceEnvironment);
245 auto gdi = new MockGdi();
246 wddm->resetGdi(gdi);
247 wddm->init();
248
249 MockOSInterface mockOsInterface;
250 auto closeHandleMock = changeSysCallMock(mockCloseHandleClb, mockCloseHandleClbData, MockOSInterface::closeHandle, &mockOsInterface);
251 mockOsInterface.setDriverModel(std::unique_ptr<DriverModel>(wddm));
252
253 gdi->destroySynchronizationObject = DestroySyncObjectMock::destroySynchObject;
254 cleanupArbSyncObject(mockOsInterface, nullptr);
255 EXPECT_EQ(0, mockOsInterface.closedEventsCount);
256 }
257
TEST_F(GlArbSyncEventOsTest,GivenValidGlSyncInfoWhenCleanupArbSyncObjectIsCalledThenProperCountOfDestructorsOfSyncAndEventsIsNotInvoked)258 TEST_F(GlArbSyncEventOsTest, GivenValidGlSyncInfoWhenCleanupArbSyncObjectIsCalledThenProperCountOfDestructorsOfSyncAndEventsIsNotInvoked) {
259 struct CreateDestroySyncObjectMock {
260 static int &getDestroyCounter() {
261 static int counter = 0;
262 return counter;
263 }
264 static NTSTATUS __stdcall destroySynchObject(_In_ CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *sync) {
265 ++getDestroyCounter();
266 return STATUS_SUCCESS;
267 }
268 static void reset() {
269 getDestroyCounter() = 0;
270 }
271 };
272 auto rootDeviceEnvironment = platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0].get();
273 rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
274
275 auto wddm = new WddmMock(*rootDeviceEnvironment);
276 auto gdi = new MockGdi();
277 wddm->resetGdi(gdi);
278 wddm->init();
279
280 MockOSInterface mockOsInterface;
281 auto closeHandleMock = changeSysCallMock(mockCloseHandleClb, mockCloseHandleClbData, MockOSInterface::closeHandle, &mockOsInterface);
282 mockOsInterface.setDriverModel(std::unique_ptr<DriverModel>(wddm));
283
284 CreateDestroySyncObjectMock::reset();
285 gdi->destroySynchronizationObject = CreateDestroySyncObjectMock::destroySynchObject;
286
287 auto ret = setupArbSyncObject(sharing, mockOsInterface, syncInfo);
288 EXPECT_TRUE(ret);
289 syncInfo.serverSynchronizationObject = 0x5cU;
290 syncInfo.clientSynchronizationObject = 0x7cU;
291 syncInfo.submissionSynchronizationObject = 0x13cU;
292
293 cleanupArbSyncObject(mockOsInterface, &syncInfo);
294 EXPECT_EQ(2, mockOsInterface.closedEventsCount);
295 EXPECT_EQ(3, CreateDestroySyncObjectMock::getDestroyCounter());
296 }
297
TEST_F(GlArbSyncEventOsTest,GivenCallToSignalArbSyncObjectWhenSignalSynchronizationObjectForServerClientSyncFailsThenSubmissionSyncDoesNotGetSignalled)298 TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchronizationObjectForServerClientSyncFailsThenSubmissionSyncDoesNotGetSignalled) {
299 struct FailSignalSyncObjectMock {
300 static NTSTATUS __stdcall signal(_In_ CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *obj) {
301 EXPECT_NE(nullptr, obj);
302 if (obj == nullptr) {
303 return STATUS_INVALID_PARAMETER;
304 }
305
306 EXPECT_EQ(2, obj->ObjectCount);
307 EXPECT_EQ(getExpectedSynchHandle0(), obj->ObjectHandleArray[0]);
308 EXPECT_EQ(getExpectedSynchHandle1(), obj->ObjectHandleArray[1]);
309 EXPECT_EQ(0, obj->Flags.SignalAtSubmission);
310 EXPECT_EQ(getExpectedContextHandle(), obj->hContext);
311 return STATUS_INVALID_PARAMETER;
312 }
313
314 static D3DKMT_HANDLE &getExpectedSynchHandle0() {
315 static D3DKMT_HANDLE handle = INVALID_HANDLE;
316 return handle;
317 }
318
319 static D3DKMT_HANDLE &getExpectedSynchHandle1() {
320 static D3DKMT_HANDLE handle = INVALID_HANDLE;
321 return handle;
322 }
323
324 static D3DKMT_HANDLE &getExpectedContextHandle() {
325 static D3DKMT_HANDLE handle = INVALID_HANDLE;
326 return handle;
327 }
328
329 static void reset() {
330 getExpectedSynchHandle0() = INVALID_HANDLE;
331 getExpectedSynchHandle1() = INVALID_HANDLE;
332 getExpectedContextHandle() = INVALID_HANDLE;
333 }
334 };
335 FailSignalSyncObjectMock::reset();
336 auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
337 wddm->init();
338 OsContextWin osContext(*wddm, 0u,
339 EngineDescriptorHelper::getDefaultDescriptor(HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0], preemptionMode));
340
341 CL_GL_SYNC_INFO syncInfo = {};
342 syncInfo.serverSynchronizationObject = 0x5cU;
343 syncInfo.clientSynchronizationObject = 0x6cU;
344
345 gdi->signalSynchronizationObject.mFunc = FailSignalSyncObjectMock::signal;
346 FailSignalSyncObjectMock::getExpectedContextHandle() = osContext.getWddmContextHandle();
347 FailSignalSyncObjectMock::getExpectedSynchHandle0() = syncInfo.serverSynchronizationObject;
348 FailSignalSyncObjectMock::getExpectedSynchHandle1() = syncInfo.clientSynchronizationObject;
349
350 signalArbSyncObject(osContext, syncInfo);
351 }
352
TEST_F(GlArbSyncEventOsTest,GivenCallToSignalArbSyncObjectWhenSignalSynchronizationObjectForServerClientSyncSucceedsThenSubmissionSyncGetsSignalledAsWell)353 TEST_F(GlArbSyncEventOsTest, GivenCallToSignalArbSyncObjectWhenSignalSynchronizationObjectForServerClientSyncSucceedsThenSubmissionSyncGetsSignalledAsWell) {
354 struct FailSignalSyncObjectMock {
355 static NTSTATUS __stdcall signal(_In_ CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *obj) {
356 EXPECT_NE(nullptr, obj);
357 if (obj == nullptr) {
358 return STATUS_INVALID_PARAMETER;
359 }
360
361 // validating only second call to signal
362 if (getCounter()++ != 1) {
363 return STATUS_SUCCESS;
364 }
365
366 EXPECT_EQ(1, obj->ObjectCount);
367 EXPECT_EQ(getExpectedSynchHandle0(), obj->ObjectHandleArray[0]);
368 EXPECT_EQ(1, obj->Flags.SignalAtSubmission);
369 EXPECT_EQ(getExpectedContextHandle(), obj->hContext);
370
371 return STATUS_SUCCESS;
372 }
373
374 static D3DKMT_HANDLE &getExpectedSynchHandle0() {
375 static D3DKMT_HANDLE handle = INVALID_HANDLE;
376 return handle;
377 }
378
379 static int &getCounter() {
380 static int counter = 0;
381 return counter;
382 }
383
384 static D3DKMT_HANDLE &getExpectedContextHandle() {
385 static D3DKMT_HANDLE handle = INVALID_HANDLE;
386 return handle;
387 }
388
389 static void reset() {
390 getExpectedSynchHandle0() = INVALID_HANDLE;
391 getCounter() = 0;
392 getExpectedContextHandle() = INVALID_HANDLE;
393 }
394 };
395 FailSignalSyncObjectMock::reset();
396 auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*defaultHwInfo);
397 wddm->init();
398 OsContextWin osContext(*wddm, 0u, EngineDescriptorHelper::getDefaultDescriptor(HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).getGpgpuEngineInstances(*defaultHwInfo)[0], preemptionMode));
399
400 CL_GL_SYNC_INFO syncInfo = {};
401 syncInfo.submissionSynchronizationObject = 0x7cU;
402
403 gdi->signalSynchronizationObject.mFunc = FailSignalSyncObjectMock::signal;
404 FailSignalSyncObjectMock::getExpectedContextHandle() = osContext.getWddmContextHandle();
405 FailSignalSyncObjectMock::getExpectedSynchHandle0() = syncInfo.submissionSynchronizationObject;
406
407 signalArbSyncObject(osContext, syncInfo);
408 }
409
TEST_F(GlArbSyncEventOsTest,GivenCallToServerWaitForArbSyncObjectWhenWaitForSynchronizationObjectFailsThenWaitFlagDoesNotGetSet)410 TEST_F(GlArbSyncEventOsTest, GivenCallToServerWaitForArbSyncObjectWhenWaitForSynchronizationObjectFailsThenWaitFlagDoesNotGetSet) {
411 struct FailWaitSyncObjectMock {
412 static NTSTATUS __stdcall waitForSynchObject(_In_ CONST_FROM_WDK_10_0_18328_0 D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *waitData) {
413 EXPECT_NE(nullptr, waitData);
414 if (waitData == nullptr) {
415 return STATUS_INVALID_PARAMETER;
416 }
417
418 EXPECT_EQ(1, waitData->ObjectCount);
419 EXPECT_EQ(getExpectedSynchHandle0(), waitData->ObjectHandleArray[0]);
420 EXPECT_EQ(getExpectedContextHandle(), waitData->hContext);
421 return STATUS_INVALID_PARAMETER;
422 }
423
424 static D3DKMT_HANDLE &getExpectedSynchHandle0() {
425 static D3DKMT_HANDLE handle = INVALID_HANDLE;
426 return handle;
427 }
428
429 static D3DKMT_HANDLE &getExpectedContextHandle() {
430 static D3DKMT_HANDLE handle = INVALID_HANDLE;
431 return handle;
432 }
433
434 static void reset() {
435 getExpectedSynchHandle0() = INVALID_HANDLE;
436 getExpectedContextHandle() = INVALID_HANDLE;
437 }
438 };
439
440 FailWaitSyncObjectMock::reset();
441
442 CL_GL_SYNC_INFO syncInfo = {};
443 syncInfo.hContextToBlock = 0x4cU;
444
445 FailWaitSyncObjectMock::getExpectedSynchHandle0() = syncInfo.serverSynchronizationObject;
446 FailWaitSyncObjectMock::getExpectedContextHandle() = syncInfo.hContextToBlock;
447 gdi->waitForSynchronizationObject.mFunc = FailWaitSyncObjectMock::waitForSynchObject;
448
449 EXPECT_FALSE(syncInfo.waitCalled);
450 serverWaitForArbSyncObject(*osInterface, syncInfo);
451 EXPECT_FALSE(syncInfo.waitCalled);
452 }
453
TEST_F(GlArbSyncEventOsTest,GivenCallToServerWaitForArbSyncObjectWhenWaitForSynchronizationObjectSucceedsThenWaitFlagGetsSet)454 TEST_F(GlArbSyncEventOsTest, GivenCallToServerWaitForArbSyncObjectWhenWaitForSynchronizationObjectSucceedsThenWaitFlagGetsSet) {
455 CL_GL_SYNC_INFO syncInfo = {};
456 syncInfo.serverSynchronizationObject = 0x7cU;
457
458 EXPECT_FALSE(syncInfo.waitCalled);
459 serverWaitForArbSyncObject(*osInterface, syncInfo);
460 EXPECT_TRUE(syncInfo.waitCalled);
461 }
462