Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Enhance va sharing unit tests 

- remove globals
- cleanup comments in code

Change-Id: I06ab9a5d0f39e5d0e34043808d0d6842c14fb6ff
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>
This commit is contained in:
Mateusz Hoppe 2019-04-15 17:20:28 +02:00 committed by sys_ocldev
parent 1e11d8939f
commit 772f0c6f09
6 changed files with 166 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
runtime/sharings/va/va_sharing_functions.h
View File

@ -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);
}

2
unit_tests/sharings/va/CMakeLists.txt
View File

@ -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

2
unit_tests/sharings/va/kernel_va_image_arg_tests.cpp
View File

@ -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());

42
unit_tests/sharings/va/mock_va_sharing.cpp
View File

@ -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

106
unit_tests/sharings/va/mock_va_sharing.h
View File

@ -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) {
vaDisplayIsValidCalled++;
return 1; // success
};
bool isValidDisplayCalled = false;
bool deriveImageCalled = false;
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 = vaSharingFunctionsMockHeight;
vaImage->width = vaSharingFunctionsMockWidth;
pitch = alignUp(vaSharingFunctionsMockWidth, 128);
vaImage->height = derivedImageHeight;
vaImage->width = derivedImageWidth;
pitch = alignUp(derivedImageWidth, 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
};
static VAStatus mockVaDestroyImage(VADisplay vaDisplay, VAImageID vaImageId) {
vaDestroyImageCalled++;
return (VAStatus)0; // success
};
static VAStatus mockVaSyncSurface(VADisplay vaDisplay, VASurfaceID vaSurface) {
vaSyncSurfaceCalled++;
return (VAStatus)0; // success
};
static void *mockVaGetLibFunc(VADisplay vaDisplay, const char *func) {
vaGetLibFuncCalled++;
return nullptr;
};
static VAStatus mockExtGetSurfaceHandle(VADisplay vaDisplay, VASurfaceID *vaSurface, unsigned int *handleId) {
vaExtGetSurfaceHandleCalled++;
*handleId = acquiredVaHandle;
return (VAStatus)0; // success
};
void initMembers();
public:
VASharingFunctionsMock(VADisplay vaDisplay) : VASharingFunctions(vaDisplay) {
initMembers();
return VA_STATUS_SUCCESS;
}
bool isValidVaDisplay() override {
isValidDisplayCalled = true;
return 1;
}
VAStatus destroyImage(VAImageID vaImageId) override {
destroyImageCalled = true;
return VA_STATUS_SUCCESS;
}
VAStatus extGetSurfaceHandle(VASurfaceID *vaSurface, unsigned int *handleId) override {
extGetSurfaceHandleCalled = true;
*handleId = acquiredVaHandle;
return VA_STATUS_SUCCESS;
}
VAStatus syncSurface(VASurfaceID vaSurface) override {
syncSurfaceCalled = true;
return VA_STATUS_SUCCESS;
}
void *getLibFunc(const char *func) override {
getLibFuncCalled = true;
return nullptr;
}
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

154
unit_tests/sharings/va/va_sharing_tests.cpp
View File

@ -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());
EXPECT_EQ(0, vaSharing->m_sharingFunctions.deriveImage(vaSurfaceId, &vaImage));
EXPECT_EQ(0, vaSharing->m_sharingFunctions.destroyImage(vaImage.image_id));
EXPECT_EQ(0, vaSharing->m_sharingFunctions.syncSurface(vaSurfaceId));
EXPECT_TRUE(nullptr == vaSharing->m_sharingFunctions.getLibFunc("funcName"));
EXPECT_EQ(0, vaSharing->m_sharingFunctions.extGetSurfaceHandle(&vaSurfaceId, &handle));
class VASharingFunctionsGlobalFunctionPointersMock : public VASharingFunctions {
public:
VASharingFunctionsGlobalFunctionPointersMock() : VASharingFunctions(nullptr) {
initMembers();
}
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);
EXPECT_EQ(1, vaDeriveImageCalled);
EXPECT_EQ(1, vaDestroyImageCalled);
EXPECT_EQ(1, vaSyncSurfaceCalled);
EXPECT_EQ(1, vaGetLibFuncCalled);
EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
void initMembers() {
vaDisplayIsValidPFN = mockVaDisplayIsValid;
vaDeriveImagePFN = mockVaDeriveImage;
vaDestroyImagePFN = mockVaDestroyImage;
vaSyncSurfacePFN = mockVaSyncSurface;
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
//overrideCommandStreamReceiverCreation = true;
ASSERT_FALSE(overrideCommandStreamReceiverCreation);
auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->m_sharingFunctions,
auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->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_EQ(1, vaDestroyImageCalled);
EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
EXPECT_TRUE(vaSharing->sharingFunctions.deriveImageCalled);
EXPECT_TRUE(vaSharing->sharingFunctions.destroyImageCalled);
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
//overrideCommandStreamReceiverCreation = true;
ASSERT_FALSE(overrideCommandStreamReceiverCreation);
vaSharingFunctionsMockWidth = 256 + 16;
vaSharingFunctionsMockHeight = 512 + 16;
auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->m_sharingFunctions,
vaSharing->sharingFunctions.derivedImageWidth = 256 + 16;
vaSharing->sharingFunctions.derivedImageHeight = 512 + 16;
auto vaSurface = VASurface::createSharedVaSurface(&context, &vaSharing->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_EQ(1, vaDestroyImageCalled);
EXPECT_EQ(1, vaExtGetSurfaceHandleCalled);
EXPECT_TRUE(vaSharing->sharingFunctions.deriveImageCalled);
EXPECT_TRUE(vaSharing->sharingFunctions.destroyImageCalled);
EXPECT_TRUE(vaSharing->sharingFunctions.extGetSurfaceHandleCalled);
SurfaceOffsets surfaceOffsets;
uint16_t alignedWidth = alignUp(vaSharingFunctionsMockWidth, 128);
uint16_t alignedHeight = alignUp(vaSharingFunctionsMockHeight, 32);
uint16_t alignedWidth = alignUp(vaSharing->sharingFunctions.derivedImageWidth, 128);
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(mockVaImage.width, static_cast<unsigned short>(sharedImg->getImageDesc().image_width));
EXPECT_EQ(vaSharing->sharingFunctions.mockVaImage.height, static_cast<unsigned short>(sharedImg->getImageDesc().image_height));
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) {