Enhance va sharing unit tests

- remove globals
- cleanup comments in code

Change-Id: I06ab9a5d0f39e5d0e34043808d0d6842c14fb6ff
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>

runtime/sharings/va/va_sharing_functions.h

@@ -22,27 +22,27 @@ class VASharingFunctions : public SharingFunctions {
     }
     static const uint32_t sharingId;
 
-    bool isValidVaDisplay() {
+    MOCKABLE_VIRTUAL bool isValidVaDisplay() {
         return vaDisplayIsValidPFN(vaDisplay) == 1;
     }
 
-    VAStatus deriveImage(VASurfaceID vaSurface, VAImage *vaImage) {
+    MOCKABLE_VIRTUAL VAStatus deriveImage(VASurfaceID vaSurface, VAImage *vaImage) {
         return vaDeriveImagePFN(vaDisplay, vaSurface, vaImage);
     }
 
-    VAStatus destroyImage(VAImageID vaImageId) {
+    MOCKABLE_VIRTUAL VAStatus destroyImage(VAImageID vaImageId) {
         return vaDestroyImagePFN(vaDisplay, vaImageId);
     }
 
-    VAStatus extGetSurfaceHandle(VASurfaceID *vaSurface, unsigned int *handleId) {
+    MOCKABLE_VIRTUAL VAStatus extGetSurfaceHandle(VASurfaceID *vaSurface, unsigned int *handleId) {
         return vaExtGetSurfaceHandlePFN(vaDisplay, vaSurface, handleId);
     }
 
-    VAStatus syncSurface(VASurfaceID vaSurface) {
+    MOCKABLE_VIRTUAL VAStatus syncSurface(VASurfaceID vaSurface) {
         return vaSyncSurfacePFN(vaDisplay, vaSurface);
     }
 
-    void *getLibFunc(const char *func) {
+    MOCKABLE_VIRTUAL void *getLibFunc(const char *func) {
         if (vaGetLibFuncPFN) {
             return vaGetLibFuncPFN(vaDisplay, func);
         }

unit_tests/sharings/va/CMakeLists.txt

@@ -12,7 +12,7 @@ set(IGDRCL_SRCS_tests_sharings_va
   ${CMAKE_CURRENT_SOURCE_DIR}/cl_get_extension_function_address_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/context_va_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_va_image_arg_tests.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/mock_va_sharing.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/mock_va_sharing.h
   ${CMAKE_CURRENT_SOURCE_DIR}/va_base_object_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/va_sharing_linux_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/va_sharing_tests.cpp

unit_tests/sharings/va/kernel_va_image_arg_tests.cpp

@@ -20,7 +20,7 @@ TEST_F(KernelImageArgTest, givenSharedImageWhenSetArgIsCalledThenReportSharedObj
     MockVaSharing vaSharing;
     VASurfaceID vaSurfaceId = 0u;
     vaSharing.updateAcquiredHandle(1u);
-    std::unique_ptr<Image> sharedImage(VASurface::createSharedVaSurface(context.get(), &vaSharing.m_sharingFunctions,
+    std::unique_ptr<Image> sharedImage(VASurface::createSharedVaSurface(context.get(), &vaSharing.sharingFunctions,
                                                                         CL_MEM_READ_WRITE, &vaSurfaceId, 0, nullptr));
 
     auto sharedMem = static_cast<cl_mem>(sharedImage.get());

unit_tests/sharings/va/mock_va_sharing.cpp

@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2017-2019 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "unit_tests/sharings/va/mock_va_sharing.h"
-
-namespace NEO {
-int vaDisplayIsValidCalled = 0;
-int vaDeriveImageCalled = 0;
-int vaDestroyImageCalled = 0;
-int vaSyncSurfaceCalled = 0;
-int vaGetLibFuncCalled = 0;
-int vaExtGetSurfaceHandleCalled = 0;
-osHandle acquiredVaHandle = 0;
-VAImage mockVaImage = {};
-uint16_t vaSharingFunctionsMockWidth, vaSharingFunctionsMockHeight;
-
-void VASharingFunctionsMock::initMembers() {
-    vaDisplayIsValidPFN = mockVaDisplayIsValid;
-    vaDeriveImagePFN = mockVaDeriveImage;
-    vaDestroyImagePFN = mockVaDestroyImage;
-    vaSyncSurfacePFN = mockVaSyncSurface;
-    vaGetLibFuncPFN = mockVaGetLibFunc;
-    vaExtGetSurfaceHandlePFN = mockExtGetSurfaceHandle;
-
-    vaDisplayIsValidCalled = 0;
-    vaDeriveImageCalled = 0;
-    vaDestroyImageCalled = 0;
-    vaSyncSurfaceCalled = 0;
-    vaGetLibFuncCalled = 0;
-    vaExtGetSurfaceHandleCalled = 0;
-
-    mockVaImage = {};
-
-    acquiredVaHandle = 0;
-    vaSharingFunctionsMockWidth = 256u;
-    vaSharingFunctionsMockHeight = 256u;
-}
-} // namespace NEO

unit_tests/sharings/va/mock_va_sharing.h

@@ -11,80 +11,82 @@
 
 namespace NEO {
 
-extern int vaDisplayIsValidCalled;
-extern int vaDeriveImageCalled;
-extern int vaDestroyImageCalled;
-extern int vaSyncSurfaceCalled;
-extern int vaGetLibFuncCalled;
-extern int vaExtGetSurfaceHandleCalled;
-extern osHandle acquiredVaHandle;
-extern VAImage mockVaImage;
-extern uint16_t vaSharingFunctionsMockWidth, vaSharingFunctionsMockHeight;
-
 class VASharingFunctionsMock : public VASharingFunctions {
+  public:
+    VAImage mockVaImage = {};
+    int32_t derivedImageFormatFourCC = VA_FOURCC_NV12;
+    int32_t derivedImageFormatBpp = 8;
+    uint16_t derivedImageHeight = 256;
+    uint16_t derivedImageWidth = 256;
 
-    static int mockVaDisplayIsValid(VADisplay vaDisplay) {
+    bool isValidDisplayCalled = false;
-        vaDisplayIsValidCalled++;
+    bool deriveImageCalled = false;
-        return 1; // success
+    bool destroyImageCalled = false;
-    };
+    bool syncSurfaceCalled = false;
+    bool getLibFuncCalled = false;
+    bool extGetSurfaceHandleCalled = false;
 
-    static VAStatus mockVaDeriveImage(VADisplay vaDisplay, VASurfaceID vaSurface, VAImage *vaImage) {
+    osHandle acquiredVaHandle = 0;
+
+    VASharingFunctionsMock(VADisplay vaDisplay) : VASharingFunctions(vaDisplay) {}
+    VASharingFunctionsMock() : VASharingFunctionsMock(nullptr){};
+
+    VAStatus deriveImage(VASurfaceID vaSurface, VAImage *vaImage) override {
+        deriveImageCalled = true;
         uint32_t pitch;
-        vaDeriveImageCalled++;
+        vaImage->height = derivedImageHeight;
-        vaImage->height = vaSharingFunctionsMockHeight;
+        vaImage->width = derivedImageWidth;
-        vaImage->width = vaSharingFunctionsMockWidth;
+        pitch = alignUp(derivedImageWidth, 128);
-        pitch = alignUp(vaSharingFunctionsMockWidth, 128);
         vaImage->offsets[1] = alignUp(vaImage->height, 32) * pitch;
         vaImage->offsets[2] = vaImage->offsets[1] + 1;
         vaImage->pitches[0] = pitch;
         vaImage->pitches[1] = pitch;
         vaImage->pitches[2] = pitch;
+        vaImage->format.fourcc = derivedImageFormatFourCC;
+        vaImage->format.bits_per_pixel = derivedImageFormatBpp;
         mockVaImage.width = vaImage->width;
         mockVaImage.height = vaImage->height;
-        return (VAStatus)0; // success
+        return VA_STATUS_SUCCESS;
-    };
+    }
-
+
-    static VAStatus mockVaDestroyImage(VADisplay vaDisplay, VAImageID vaImageId) {
+    bool isValidVaDisplay() override {
-        vaDestroyImageCalled++;
+        isValidDisplayCalled = true;
-        return (VAStatus)0; // success
+        return 1;
-    };
+    }
-
+
-    static VAStatus mockVaSyncSurface(VADisplay vaDisplay, VASurfaceID vaSurface) {
+    VAStatus destroyImage(VAImageID vaImageId) override {
-        vaSyncSurfaceCalled++;
+        destroyImageCalled = true;
-        return (VAStatus)0; // success
+        return VA_STATUS_SUCCESS;
-    };
+    }
-
+
-    static void *mockVaGetLibFunc(VADisplay vaDisplay, const char *func) {
+    VAStatus extGetSurfaceHandle(VASurfaceID *vaSurface, unsigned int *handleId) override {
-        vaGetLibFuncCalled++;
+        extGetSurfaceHandleCalled = true;
-        return nullptr;
+        *handleId = acquiredVaHandle;
-    };
+        return VA_STATUS_SUCCESS;
-
+    }
-    static VAStatus mockExtGetSurfaceHandle(VADisplay vaDisplay, VASurfaceID *vaSurface, unsigned int *handleId) {
+
-        vaExtGetSurfaceHandleCalled++;
+    VAStatus syncSurface(VASurfaceID vaSurface) override {
-        *handleId = acquiredVaHandle;
+        syncSurfaceCalled = true;
-        return (VAStatus)0; // success
+        return VA_STATUS_SUCCESS;
-    };
+    }
-
+
-    void initMembers();
+    void *getLibFunc(const char *func) override {
-
+        getLibFuncCalled = true;
-  public:
+        return nullptr;
-    VASharingFunctionsMock(VADisplay vaDisplay) : VASharingFunctions(vaDisplay) {
-        initMembers();
     }
-    VASharingFunctionsMock() : VASharingFunctionsMock(nullptr){};
 };
 
 class MockVaSharing {
   public:
     void updateAcquiredHandle() {
-        acquiredVaHandle = sharingHandle;
+        sharingFunctions.acquiredVaHandle = sharingHandle;
     }
     void updateAcquiredHandle(unsigned int handle) {
         sharingHandle = handle;
-        acquiredVaHandle = sharingHandle;
+        sharingFunctions.acquiredVaHandle = sharingHandle;
     }
 
-    VASharingFunctionsMock m_sharingFunctions;
+    VASharingFunctionsMock sharingFunctions;
     osHandle sharingHandle = 0;
 };
 } // namespace NEO

unit_tests/sharings/va/va_sharing_tests.cpp

@@ -25,7 +25,7 @@ class VaSharingTests : public ::testing::Test, public PlatformFixture {
     void SetUp() override {
         PlatformFixture::SetUp();
         vaSharing = new MockVaSharing;
-        context.setSharingFunctions(&vaSharing->m_sharingFunctions);
+        context.setSharingFunctions(&vaSharing->sharingFunctions);
         vaSharing->updateAcquiredHandle(sharingHandle);
         sharedImg = nullptr;
         sharedClMem = nullptr;
@@ -63,32 +63,86 @@ class VaSharingTests : public ::testing::Test, public PlatformFixture {
     unsigned int sharingHandle = 1u;
 };
 
-TEST_F(VaSharingTests, givenMockVAWhenFunctionsAreCalledThenCallsAreReceived) {
+TEST_F(VaSharingTests, givenVASharingFunctionsObjectWhenFunctionsAreCalledThenCallsAreRedirectedToVaFunctionPointers) {
     unsigned int handle = 0u;
 
-    EXPECT_TRUE(vaSharing->m_sharingFunctions.isValidVaDisplay());
+    class VASharingFunctionsGlobalFunctionPointersMock : public VASharingFunctions {
-    EXPECT_EQ(0, vaSharing->m_sharingFunctions.deriveImage(vaSurfaceId, &vaImage));
+      public:
-    EXPECT_EQ(0, vaSharing->m_sharingFunctions.destroyImage(vaImage.image_id));
+        VASharingFunctionsGlobalFunctionPointersMock() : VASharingFunctions(nullptr) {
-    EXPECT_EQ(0, vaSharing->m_sharingFunctions.syncSurface(vaSurfaceId));
+            initMembers();
-    EXPECT_TRUE(nullptr == vaSharing->m_sharingFunctions.getLibFunc("funcName"));
+        }
-    EXPECT_EQ(0, vaSharing->m_sharingFunctions.extGetSurfaceHandle(&vaSurfaceId, &handle));
 
-    EXPECT_EQ(sharingHandle, handle);
+        bool vaDisplayIsValidCalled = false;
+        bool vaDeriveImageCalled = false;
+        bool vaDestroyImageCalled = false;
+        bool vaSyncSurfaceCalled = false;
+        bool vaGetLibFuncCalled = false;
+        bool vaExtGetSurfaceHandleCalled = false;
 
-    EXPECT_EQ(1, vaDisplayIsValidCalled);
+        void initMembers() {
-    EXPECT_EQ(1, vaDeriveImageCalled);
+            vaDisplayIsValidPFN = mockVaDisplayIsValid;
-    EXPECT_EQ(1, vaDestroyImageCalled);
+            vaDeriveImagePFN = mockVaDeriveImage;
-    EXPECT_EQ(1, vaSyncSurfaceCalled);
+            vaDestroyImagePFN = mockVaDestroyImage;
-    EXPECT_EQ(1, vaGetLibFuncCalled);
+            vaSyncSurfacePFN = mockVaSyncSurface;
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+            vaGetLibFuncPFN = mockVaGetLibFunc;
+            vaExtGetSurfaceHandlePFN = mockExtGetSurfaceHandle;
+        }
+
+        static VASharingFunctionsGlobalFunctionPointersMock &getInstance() {
+            static VASharingFunctionsGlobalFunctionPointersMock vaSharingFunctions;
+            return vaSharingFunctions;
+        }
+
+        static int mockVaDisplayIsValid(VADisplay vaDisplay) {
+            getInstance().vaDisplayIsValidCalled = true;
+            return 1;
+        };
+
+        static VAStatus mockVaDeriveImage(VADisplay vaDisplay, VASurfaceID vaSurface, VAImage *vaImage) {
+            getInstance().vaDeriveImageCalled = true;
+            return VA_STATUS_SUCCESS;
+        };
+
+        static VAStatus mockVaDestroyImage(VADisplay vaDisplay, VAImageID vaImageId) {
+            getInstance().vaDestroyImageCalled = true;
+            return VA_STATUS_SUCCESS;
+        };
+
+        static VAStatus mockVaSyncSurface(VADisplay vaDisplay, VASurfaceID vaSurface) {
+            getInstance().vaSyncSurfaceCalled = true;
+            return VA_STATUS_SUCCESS;
+        };
+
+        static void *mockVaGetLibFunc(VADisplay vaDisplay, const char *func) {
+            getInstance().vaGetLibFuncCalled = true;
+            return nullptr;
+        };
+
+        static VAStatus mockExtGetSurfaceHandle(VADisplay vaDisplay, VASurfaceID *vaSurface, unsigned int *handleId) {
+            getInstance().vaExtGetSurfaceHandleCalled = true;
+            return VA_STATUS_SUCCESS;
+        };
+    };
+    auto &vaSharingFunctions = VASharingFunctionsGlobalFunctionPointersMock::getInstance();
+    EXPECT_TRUE(vaSharingFunctions.isValidVaDisplay());
+    EXPECT_EQ(0, vaSharingFunctions.deriveImage(vaSurfaceId, &vaImage));
+    EXPECT_EQ(0, vaSharingFunctions.destroyImage(vaImage.image_id));
+    EXPECT_EQ(0, vaSharingFunctions.syncSurface(vaSurfaceId));
+    EXPECT_TRUE(nullptr == vaSharingFunctions.getLibFunc("funcName"));
+    EXPECT_EQ(0, vaSharingFunctions.extGetSurfaceHandle(&vaSurfaceId, &handle));
+
+    EXPECT_EQ(0u, handle);
+
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaDisplayIsValidCalled);
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaDeriveImageCalled);
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaDestroyImageCalled);
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaSyncSurfaceCalled);
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaGetLibFuncCalled);
+    EXPECT_TRUE(VASharingFunctionsGlobalFunctionPointersMock::getInstance().vaExtGetSurfaceHandleCalled);
 }
 
 TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedThenMemObjectHasVaHandler) {
-    // this will create OS specific memory Manager
+    auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
-    //overrideCommandStreamReceiverCreation = true;
-    ASSERT_FALSE(overrideCommandStreamReceiverCreation);
-
-    auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->m_sharingFunctions,
                                                       CL_MEM_READ_WRITE, &vaSurfaceId, 0, &errCode);
     EXPECT_NE(nullptr, vaSurface);
     EXPECT_NE(nullptr, vaSurface->getGraphicsAllocation());
@@ -101,13 +155,13 @@ TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedThenMemObjectHasVaHandle
     ASSERT_NE(nullptr, handler);
 
     auto vaHandler = static_cast<VASharing *>(handler);
-    EXPECT_EQ(vaHandler->peekFunctionsHandler(), &vaSharing->m_sharingFunctions);
+    EXPECT_EQ(vaHandler->peekFunctionsHandler(), &vaSharing->sharingFunctions);
 
-    EXPECT_EQ(1u, acquiredVaHandle);
+    EXPECT_EQ(1u, vaSharing->sharingFunctions.acquiredVaHandle);
 
-    EXPECT_EQ(1, vaDeriveImageCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.deriveImageCalled);
-    EXPECT_EQ(1, vaDestroyImageCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.destroyImageCalled);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 
     size_t paramSize = 0;
     void *paramValue = nullptr;
@@ -120,12 +174,9 @@ TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedThenMemObjectHasVaHandle
 }
 
 TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedWithNotAlignedWidthAndHeightThenSurfaceOffsetsUseAlignedValues) {
-    // this will create OS specific memory Manager
+    vaSharing->sharingFunctions.derivedImageWidth = 256 + 16;
-    //overrideCommandStreamReceiverCreation = true;
+    vaSharing->sharingFunctions.derivedImageHeight = 512 + 16;
-    ASSERT_FALSE(overrideCommandStreamReceiverCreation);
+    auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->sharingFunctions,
-    vaSharingFunctionsMockWidth = 256 + 16;
-    vaSharingFunctionsMockHeight = 512 + 16;
-    auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->m_sharingFunctions,
                                                       CL_MEM_READ_WRITE, &vaSurfaceId, 1, &errCode);
     EXPECT_NE(nullptr, vaSurface);
     EXPECT_NE(nullptr, vaSurface->getGraphicsAllocation());
@@ -138,17 +189,17 @@ TEST_F(VaSharingTests, givenMockVaWhenVaSurfaceIsCreatedWithNotAlignedWidthAndHe
     ASSERT_NE(nullptr, handler);
 
     auto vaHandler = static_cast<VASharing *>(handler);
-    EXPECT_EQ(vaHandler->peekFunctionsHandler(), &vaSharing->m_sharingFunctions);
+    EXPECT_EQ(vaHandler->peekFunctionsHandler(), &vaSharing->sharingFunctions);
 
-    EXPECT_EQ(1u, acquiredVaHandle);
+    EXPECT_EQ(1u, vaSharing->sharingFunctions.acquiredVaHandle);
 
-    EXPECT_EQ(1, vaDeriveImageCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.deriveImageCalled);
-    EXPECT_EQ(1, vaDestroyImageCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.destroyImageCalled);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 
     SurfaceOffsets surfaceOffsets;
-    uint16_t alignedWidth = alignUp(vaSharingFunctionsMockWidth, 128);
+    uint16_t alignedWidth = alignUp(vaSharing->sharingFunctions.derivedImageWidth, 128);
-    uint16_t alignedHeight = alignUp(vaSharingFunctionsMockHeight, 32);
+    uint16_t alignedHeight = alignUp(vaSharing->sharingFunctions.derivedImageHeight, 32);
     uint64_t alignedOffset = alignedWidth * alignedHeight;
 
     vaSurface->getSurfaceOffsets(surfaceOffsets);
@@ -173,29 +224,32 @@ TEST_F(VaSharingTests, givenVASurfaceWhenItIsAcquiredTwiceThenAcquireIsNotCalled
     createMediaSurface();
 
     sharedImg->peekSharingHandler()->acquire(sharedImg);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 
+    vaSharing->sharingFunctions.extGetSurfaceHandleCalled = false;
     sharedImg->peekSharingHandler()->acquire(sharedImg);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 }
 
-TEST_F(VaSharingTests, givenHwCommandQueueWhenAcquireIsCalledThenAcquireCountIsNotIncremented) {
+TEST_F(VaSharingTests, givenHwCommandQueueWhenEnqueueAcquireIsCalledMultipleTimesThenSharingFunctionAcquireIsNotCalledMultipleTimes) {
     auto commandQueue = clCreateCommandQueue(&context, context.getDevice(0), 0, &errCode);
     ASSERT_EQ(CL_SUCCESS, errCode);
 
     createMediaSurface();
 
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
+
+    vaSharing->sharingFunctions.extGetSurfaceHandleCalled = false;
     errCode = clEnqueueAcquireVA_APIMediaSurfacesINTEL(commandQueue, 1, &sharedClMem, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, errCode);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 
     errCode = clEnqueueReleaseVA_APIMediaSurfacesINTEL(commandQueue, 1, &sharedClMem, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, errCode);
 
     errCode = clEnqueueAcquireVA_APIMediaSurfacesINTEL(commandQueue, 1, &sharedClMem, 0, nullptr, nullptr);
     EXPECT_EQ(CL_SUCCESS, errCode);
-    EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
 
     errCode = clReleaseCommandQueue(commandQueue);
     EXPECT_EQ(CL_SUCCESS, errCode);
@@ -292,8 +346,8 @@ TEST_F(VaSharingTests, givenSimpleParamsWhenCreateSurfaceIsCalledThenSetImgObjec
     EXPECT_TRUE(sharedImg->getImageDesc().buffer == nullptr);
     EXPECT_EQ(0u, sharedImg->getImageDesc().image_array_size);
     EXPECT_EQ(0u, sharedImg->getImageDesc().image_depth);
-    EXPECT_EQ(mockVaImage.height, static_cast<unsigned short>(sharedImg->getImageDesc().image_height));
+    EXPECT_EQ(vaSharing->sharingFunctions.mockVaImage.height, static_cast<unsigned short>(sharedImg->getImageDesc().image_height));
-    EXPECT_EQ(mockVaImage.width, static_cast<unsigned short>(sharedImg->getImageDesc().image_width));
+    EXPECT_EQ(vaSharing->sharingFunctions.mockVaImage.width, static_cast<unsigned short>(sharedImg->getImageDesc().image_width));
     EXPECT_TRUE(CL_MEM_OBJECT_IMAGE2D == sharedImg->getImageDesc().image_type);
     EXPECT_EQ(0u, sharedImg->getImageDesc().image_slice_pitch);
     EXPECT_NE(0u, sharedImg->getImageDesc().image_row_pitch);
@@ -312,9 +366,9 @@ TEST_F(VaSharingTests, givenNonInteropUserSyncContextWhenAcquireIsCalledThenSync
 
     auto memObj = castToObject<MemObj>(sharedClMem);
 
-    EXPECT_EQ(0, vaSyncSurfaceCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.syncSurfaceCalled);
     memObj->peekSharingHandler()->acquire(sharedImg);
-    EXPECT_EQ(1, vaSyncSurfaceCalled);
+    EXPECT_TRUE(vaSharing->sharingFunctions.syncSurfaceCalled);
 }
 
 TEST_F(VaSharingTests, givenInteropUserSyncContextWhenAcquireIsCalledThenDontSyncSurface) {
@@ -322,9 +376,9 @@ TEST_F(VaSharingTests, givenInteropUserSyncContextWhenAcquireIsCalledThenDontSyn
 
     createMediaSurface();
 
-    EXPECT_EQ(0, vaSyncSurfaceCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.syncSurfaceCalled);
     sharedImg->peekSharingHandler()->acquire(sharedImg);
-    EXPECT_EQ(0, vaSyncSurfaceCalled);
+    EXPECT_FALSE(vaSharing->sharingFunctions.syncSurfaceCalled);
 }
 
 TEST_F(VaSharingTests, givenYuvPlaneWhenCreateIsCalledThenChangeWidthAndHeight) {