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