From: Jean-Philippe Bruyère Date: Sun, 23 Mar 2025 15:55:59 +0000 (+0100) Subject: unit tests wip X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=9124b05c3e3746f2103801c70944d8f0159c71f3;p=jp%2Fvkvg.git unit tests wip --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 9049b54..8fe84d3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,9 +12,9 @@ SET(CMAKE_CXX_STANDARD 11) PROJECT(vkvg VERSION 0.3.0 DESCRIPTION "Vulkan Vector Graphic") ADD_COMPILE_DEFINITIONS( - "VKVG_VERSION_MAJOR=${vkvg_VERSION_MAJOR}" - "VKVG_VERSION_MINOR=${vkvg_VERSION_MINOR}" - "VKVG_VERSION_REVISION=${vkvg_VERSION_PATCH}" + "VKVG_VERSION_MAJOR=${vkvg_VERSION_MAJOR}" + "VKVG_VERSION_MINOR=${vkvg_VERSION_MINOR}" + "VKVG_VERSION_REVISION=${vkvg_VERSION_PATCH}" ) INCLUDE(CheckSymbolExists) @@ -233,26 +233,27 @@ IF(GLSLC AND XXD) ENDIF() IF (VKVG_USE_GLUTESS) - ADD_DEFINITIONS (-DVKVG_FILL_NZ_GLUTESS) - ADD_SUBDIRECTORY (external/glutess) + ADD_DEFINITIONS (-DVKVG_FILL_NZ_GLUTESS) + ADD_SUBDIRECTORY (external/glutess) ENDIF () FILE(GLOB VKVG_SRC src/*.c src/deps/*.c) +FILE(GLOB VKVG_HEADERS src/*.h) SET (VKVG_PUBLIC_HEADERS "include/vkvg.h;include/vkvg-svg.h") IF (VKVG_SVG) - ADD_DEFINITIONS (-DVKVG_SVG) - FILE(GLOB SVG_SRC external/vkvg-svg/src/*.c) + ADD_DEFINITIONS (-DVKVG_SVG) + FILE(GLOB SVG_SRC external/vkvg-svg/src/*.c) ELSE() - FILE(GLOB SVG_SRC src/nsvg/*.c) + FILE(GLOB SVG_SRC src/nsvg/*.c) ENDIF() LIST (APPEND VKVG_SRC ${SVG_SRC}) IF (VKVG_RECORDING) - ADD_DEFINITIONS (-DVKVG_RECORDING) - FILE(GLOB RECORDING_SRC src/recording/*.c) - LIST (APPEND VKVG_SRC ${RECORDING_SRC}) + ADD_DEFINITIONS (-DVKVG_RECORDING) + FILE(GLOB RECORDING_SRC src/recording/*.c) + LIST (APPEND VKVG_SRC ${RECORDING_SRC}) ENDIF() CONFIGURE_FILE(vkvg.pc.in vkvg.pc @ONLY) @@ -265,7 +266,8 @@ LIST(APPEND VKVG_SRC ${SHADERS} ${SHADERS_H}) SOURCE_GROUP(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${VKVG_SRC}) -ADD_LIBRARY("${PROJECT_NAME}" ${VKVG_SRC}) + +ADD_LIBRARY("${PROJECT_NAME}" ${VKVG_SRC} ${VKVG_HEADERS}) SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES OUTPUT_NAME ${PROJECT_NAME} @@ -291,51 +293,51 @@ TARGET_INCLUDE_DIRECTORIES("${PROJECT_NAME}" ) IF (UNIX AND BUILD_SHARED_LIBS) - #make libm public for shared build to solve libm missing for common_test object lib linking even - #if -lm present on cc command. - TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC m) + #make libm public for shared build to solve libm missing for common_test object lib linking even + #if -lm present on cc command. + TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC m) ENDIF() IF(VKVG_USE_FREETYPE) - TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC ${FREETYPE_LIBRARY}) + TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC ${FREETYPE_LIBRARY}) ENDIF() IF(VKVG_USE_FONTCONFIG) - TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${Fontconfig_LIBRARIES}) + TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${Fontconfig_LIBRARIES}) ENDIF() IF(VKVG_USE_HARFBUZZ) - TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${HarfBuzz_LIBRARIES}) + TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${HarfBuzz_LIBRARIES}) ENDIF() IF(VKVG_USE_GLUTESS) - TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE glutess) + TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE glutess) ENDIF() TARGET_LINK_LIBRARIES("${PROJECT_NAME}" - PUBLIC - ${Vulkan_LIBRARIES} - vkh + PUBLIC + ${Vulkan_LIBRARIES} + vkh ) IF (SHADERS_H) - ADD_DEPENDENCIES("${PROJECT_NAME}" BuildShadersHeader) + ADD_DEPENDENCIES("${PROJECT_NAME}" BuildShadersHeader) ENDIF() INSTALL(TARGETS "${PROJECT_NAME}" "${PROJECT_NAME}" - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) IF (VKVG_BUILD_TESTS) - ADD_SUBDIRECTORY(tests) + ADD_SUBDIRECTORY(tests) ELSEIF (VKVG_BUILD_OFFSCREEN_TEST) - ADD_EXECUTABLE(test_offscreen "${CMAKE_CURRENT_SOURCE_DIR}/tests/offscreen.c") - TARGET_INCLUDE_DIRECTORIES(test_offscreen PRIVATE - ${Vulkan_INCLUDE_DIRS} - ${CMAKE_CURRENT_SOURCE_DIR}/include - ) - TARGET_LINK_LIBRARIES(test_offscreen - vkvg - ${Vulkan_LIBRARIES} - ) + ADD_EXECUTABLE(test_offscreen "${CMAKE_CURRENT_SOURCE_DIR}/tests/offscreen.c") + TARGET_INCLUDE_DIRECTORIES(test_offscreen PRIVATE + ${Vulkan_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR}/include + ) + TARGET_LINK_LIBRARIES(test_offscreen + vkvg + ${Vulkan_LIBRARIES} + ) ENDIF (VKVG_BUILD_TESTS) IF (VKVG_BUILD_DOCS) diff --git a/gunit_tests/CMakeLists.txt b/gunit_tests/CMakeLists.txt index 6e45efe..bc24a21 100644 --- a/gunit_tests/CMakeLists.txt +++ b/gunit_tests/CMakeLists.txt @@ -28,6 +28,9 @@ add_executable("${PROJECT_NAME}" basicDraw.cpp drawTestBase.cpp drawTestBase.h + imageDraw.cpp + matrices.cpp + patternDraw.cpp ) target_compile_definitions("${PROJECT_NAME}" PUBLIC GTEST_PNG_ROOT="${GTEST_PNG_ROOT}" diff --git a/gunit_tests/context.cpp b/gunit_tests/context.cpp index 0c02146..ef2e185 100644 --- a/gunit_tests/context.cpp +++ b/gunit_tests/context.cpp @@ -65,7 +65,7 @@ TEST_F(ContextTest, CtxReference) { vkvg_destroy(ctx); EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev)); EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); - EXPECT_EQ(0, vkvg_get_reference_count(ctx)); + //EXPECT_EQ(0, vkvg_get_reference_count(ctx)); EXPECT_EQ(1, vkvg_surface_get_reference_count(surf)); EXPECT_EQ(2, vkvg_device_get_reference_count(dev)); } diff --git a/gunit_tests/device.cpp b/gunit_tests/device.cpp index bce3fea..1365bb7 100644 --- a/gunit_tests/device.cpp +++ b/gunit_tests/device.cpp @@ -37,7 +37,7 @@ TEST(Device, Reference) { EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev)); vkvg_device_destroy(dev); - EXPECT_EQ(0, vkvg_device_get_reference_count(dev)); + //EXPECT_EQ(0, vkvg_device_get_reference_count(dev)); } /*TEST(Device, GetVulkanRequirements) diff --git a/gunit_tests/imageDraw.cpp b/gunit_tests/imageDraw.cpp new file mode 100644 index 0000000..3f0a93f --- /dev/null +++ b/gunit_tests/imageDraw.cpp @@ -0,0 +1,133 @@ +#include "drawTestBase.h" + +class ImageDrawTest : public DrawTestBase { + + protected: + fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2.png"; + VkvgSurface imgSurf; + + void SetUp() override { + surf = vkvg_surface_create(dev, 512, 512); + imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str()); + } + void TearDown() override { + vkvg_surface_destroy(imgSurf); + DrawTestBase::TearDown(); + } +}; +TEST_F(ImageDrawTest, References) { + EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(NULL)); + EXPECT_EQ(0, vkvg_surface_get_reference_count(NULL)); + EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(NULL)); + + VkvgSurface surf2 = vkvg_surface_create_from_image(NULL, NULL); + EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(surf2)); + surf2 = vkvg_surface_create_from_image(dev, NULL); + EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(surf2)); + + uint32_t devRefCntInit = vkvg_device_get_reference_count(dev); + + surf2 = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str()); + EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf2)); + EXPECT_EQ(1, vkvg_surface_get_reference_count(surf2)); + EXPECT_EQ(devRefCntInit + 1, vkvg_device_get_reference_count(dev)); + EXPECT_EQ(285, vkvg_surface_get_width(surf2)); + EXPECT_EQ(285, vkvg_surface_get_height(surf2)); + + vkvg_surface_reference(surf2); + EXPECT_EQ(2, vkvg_surface_get_reference_count(surf2)); + + vkvg_surface_destroy(surf2); + + EXPECT_EQ(1, vkvg_surface_get_reference_count(surf2)); + vkvg_surface_destroy(surf2); + //EXPECT_EQ(NULL, surf2); + EXPECT_EQ(devRefCntInit, vkvg_device_get_reference_count(dev)); +} + +TEST_F(ImageDrawTest, PaintImage) { + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_surface(ctx, imgSurf, 0, 0); + EXPECT_EQ(2, vkvg_surface_get_reference_count(imgSurf)); + vkvg_paint(ctx); + vkvg_destroy(ctx); + EXPECT_EQ(1, vkvg_surface_get_reference_count(imgSurf)); + + compareWithRefImage(); +} +TEST_F(ImageDrawTest, PaintImageOffset) { + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f); + vkvg_paint(ctx); + + vkvg_set_source_surface(ctx, imgSurf, 50, 50); + vkvg_paint(ctx); + vkvg_destroy(ctx); + + compareWithRefImage(); +} +TEST_F(ImageDrawTest, PaintImageRotateOffset) { + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f); + vkvg_paint(ctx); + + vkvg_rotate(ctx, 1.2f); + vkvg_set_source_surface(ctx, imgSurf, 100, 100); + vkvg_paint(ctx); + vkvg_destroy(ctx); + + compareWithRefImage(); +} +TEST_F(ImageDrawTest, PaintImageRotateInPlace) { + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f); + vkvg_paint(ctx); + vkvg_matrix_t mat; + vkvg_matrix_init_translate(&mat, 142,142); + vkvg_matrix_rotate(&mat,0.1f); + vkvg_matrix_init_translate(&mat, -142,-142); + + vkvg_set_source_surface(ctx, imgSurf, 50, 50); + vkvg_set_matrix(ctx, &mat); + vkvg_paint(ctx); + vkvg_destroy(ctx); + + compareWithRefImage(); +} + +TEST_F(ImageDrawTest, PaintImageTransform) { + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f); + vkvg_paint(ctx); + + fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2-64.png"; + VkvgSurface imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str()); + + vkvg_translate(ctx, 10, 10); + vkvg_set_source_surface(ctx, imgSurf, 0, 0); + vkvg_paint(ctx); + + vkvg_identity_matrix(ctx); + vkvg_translate(ctx, 80, 0); + vkvg_scale(ctx, 2.f, 1.f); + vkvg_paint(ctx); + + vkvg_identity_matrix(ctx); + vkvg_translate(ctx, 240, 0); + vkvg_scale(ctx, 2.f, 2.f); + vkvg_paint(ctx); + + vkvg_identity_matrix(ctx); + vkvg_translate(ctx, 0, 80); + vkvg_translate(ctx, -32, -32); + vkvg_rotate(ctx, 1.2f); + vkvg_translate(ctx, 32, 32); + + vkvg_paint(ctx); + + vkvg_destroy(ctx); + + compareWithRefImage(); +} + + diff --git a/gunit_tests/matrices.cpp b/gunit_tests/matrices.cpp new file mode 100644 index 0000000..040ce61 --- /dev/null +++ b/gunit_tests/matrices.cpp @@ -0,0 +1,70 @@ +#include "vkvg.h" +#include + +#define CHECK_MAT(_xx,_yx,_xy,_yy,_x0,_y0) \ +EXPECT_FLOAT_EQ (mat.xx, _xx);EXPECT_FLOAT_EQ (mat.yx, _yx);\ +EXPECT_FLOAT_EQ (mat.xy, _xy);EXPECT_FLOAT_EQ (mat.yy, _yy);\ +EXPECT_FLOAT_EQ (mat.x0, _x0);EXPECT_FLOAT_EQ (mat.y0, _y0); + + +TEST(MatrixTest, MatixInit) { + vkvg_matrix_t mat = VKVG_IDENTITY_MATRIX; + CHECK_MAT(1,0,0,1,0,0); + + vkvg_matrix_init_identity(&mat); + CHECK_MAT(1,0,0,1,0,0); + + vkvg_matrix_init(&mat, 1.3f, 2.5f, 0.3f, 0.7f, 1.2f, 1.7f); + CHECK_MAT(1.3f, 2.5f, 0.3f, 0.7f, 1.2f, 1.7f); + + float a,b; + + vkvg_matrix_init_translate(&mat, 1.3f, 2.5f); + CHECK_MAT(1,0,0,1,1.3f,2.5f); + + vkvg_matrix_init_scale(&mat, 2.1f, 1.5f); + CHECK_MAT(2.1f,0,0,1.5f,0,0); + vkvg_matrix_get_scale(&mat, &a, &b); + EXPECT_FLOAT_EQ(a,2.1f); + EXPECT_FLOAT_EQ(b,1.5f); + + vkvg_matrix_init_rotate(&mat, 2.f); + CHECK_MAT(cosf(2.f),sinf(2.f),-sinf(2.f),cosf(2.f),0,0); +} + +TEST(MatrixTest, MatixOperation) { + vkvg_matrix_t mat = {0,0,0,0,0,0}; + //TODO + +} +TEST(MatrixTest, MatixIvert) { + vkvg_matrix_t mat = {0,0,0,0,0,0}; + vkvg_status_t res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_INVALID_MATRIX); + + mat = {1,1,0,0,0,0}; + res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_INVALID_MATRIX); + + mat = {1,0,0,1,0,0}; + res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_SUCCESS); + CHECK_MAT(1,0,0,1,0,0); + + vkvg_matrix_init_scale(&mat, 2.1f, 1.5f); + res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_SUCCESS); + CHECK_MAT(1.f/2.1f,0,0,1.f/1.5f,0,0); + + vkvg_matrix_init_translate(&mat, 2.1f, 1.5f); + res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_SUCCESS); + CHECK_MAT(1,0,0,1,-2.1f,-1.5f); + + vkvg_matrix_init_rotate(&mat, 2.f); + res = vkvg_matrix_invert(&mat); + EXPECT_EQ(res,VKVG_STATUS_SUCCESS); + CHECK_MAT(cosf(2.f),-sinf(2.f),sinf(2.f),cosf(2.f),0,0); + + +} diff --git a/gunit_tests/patternDraw.cpp b/gunit_tests/patternDraw.cpp new file mode 100644 index 0000000..e550340 --- /dev/null +++ b/gunit_tests/patternDraw.cpp @@ -0,0 +1,88 @@ +#include "drawTestBase.h" + +class PatternDrawTest : public DrawTestBase { + + protected: + fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2.png"; + VkvgSurface imgSurf; + + void SetUp() override { + surf = vkvg_surface_create(dev, 512, 512); + imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str()); + } + void TearDown() override { + vkvg_surface_destroy(imgSurf); + DrawTestBase::TearDown(); + } +}; +TEST_F(PatternDrawTest, References) { + EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_pattern_status(NULL)); + EXPECT_EQ(0, vkvg_pattern_get_reference_count(NULL)); + EXPECT_NO_FATAL_FAILURE(vkvg_pattern_reference(NULL)); + + VkvgPattern pat = vkvg_pattern_create_for_surface(NULL); + EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_pattern_status(pat)); + + pat = vkvg_pattern_create_linear(0,0,0,0); + EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_pattern_status(pat)); + EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat)); + vkvg_pattern_reference(pat); + EXPECT_EQ(2, vkvg_pattern_get_reference_count(pat)); + + EXPECT_NO_FATAL_FAILURE(vkvg_pattern_destroy(NULL)); + vkvg_pattern_destroy(pat); + EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat)); + vkvg_pattern_destroy(pat); + //EXPECT_EQ(NULL, pat); +} + +TEST_F(PatternDrawTest, PaintPattern) { + + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf); + EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_pattern_status(pat)); + EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat)); + EXPECT_EQ(2, vkvg_surface_get_reference_count(imgSurf)); + vkvg_set_source(ctx, pat); + EXPECT_EQ(2, vkvg_pattern_get_reference_count(pat)); + vkvg_paint(ctx); + vkvg_pattern_destroy(pat); + EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat)); + vkvg_destroy(ctx); + + compareWithRefImage(); +} +TEST_F(PatternDrawTest, PaintPatternRepeat) { + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf); + vkvg_pattern_set_extend(pat, VKVG_EXTEND_REPEAT); + vkvg_set_source(ctx, pat); + vkvg_paint(ctx); + vkvg_pattern_destroy(pat); + vkvg_destroy(ctx); + + compareWithRefImage(); +} +TEST_F(PatternDrawTest, PaintPatternRepeatScaled) { + VkvgContext ctx = vkvg_create(surf); + vkvg_scale(ctx, 0.2f, 0.2f); + VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf); + vkvg_pattern_set_extend(pat, VKVG_EXTEND_REPEAT); + vkvg_set_source(ctx, pat); + vkvg_paint(ctx); + vkvg_pattern_destroy(pat); + vkvg_destroy(ctx); + + compareWithRefImage(); +} +TEST_F(PatternDrawTest, PaintPatternPad) { + VkvgContext ctx = vkvg_create(surf); + VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf); + vkvg_pattern_set_extend(pat, VKVG_EXTEND_PAD); + vkvg_set_source(ctx, pat); + vkvg_paint(ctx); + vkvg_pattern_destroy(pat); + vkvg_destroy(ctx); + + compareWithRefImage(); +} diff --git a/gunit_tests/surface.cpp b/gunit_tests/surface.cpp index f4284d7..91d3f4a 100644 --- a/gunit_tests/surface.cpp +++ b/gunit_tests/surface.cpp @@ -20,14 +20,27 @@ class SurfaceTest : public testing::Test { void SetUp() override {} void TearDown() override {} + + void checkPixels(VkvgSurface surf, uint32_t expectedPixelValue) { + uint32_t w = vkvg_surface_get_width(surf); + uint32_t h = vkvg_surface_get_height(surf); + uint32_t* buff = (uint32_t*)malloc(w * h * sizeof(uint32_t)); + vkvg_surface_write_to_memory(surf, (unsigned char*)buff); + + for (int i = 0; i < w * h; ++i) { + EXPECT_EQ(expectedPixelValue, buff[i]); + } + free(buff); + } }; TEST_F(SurfaceTest, SurfCreate) { EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(NULL)); + EXPECT_NO_FATAL_FAILURE(vkvg_surface_destroy(NULL)); VkvgSurface surf = vkvg_surface_create(NULL, 0, 0); - EXPECT_EQ(VKVG_STATUS_DEVICE_ERROR, vkvg_surface_status(surf)); + EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(surf)); surf = vkvg_surface_create(dev, 512, 512); @@ -38,30 +51,69 @@ TEST_F(SurfaceTest, SurfCreate) { } TEST_F(SurfaceTest, SurfReference) { + EXPECT_EQ(0, vkvg_surface_get_reference_count(NULL)); + EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(NULL)); + VkvgSurface surf = vkvg_surface_create(NULL, 0, 0); EXPECT_EQ(0, vkvg_surface_get_reference_count(surf)); - vkvg_surface_reference(surf); - EXPECT_EQ(VKVG_STATUS_DEVICE_ERROR, vkvg_surface_status(surf)); + EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(surf)); + + uint32_t devRefCntInit = vkvg_device_get_reference_count(dev); surf = vkvg_surface_create(dev, 512, 512); EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev)); EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); - EXPECT_EQ(2, vkvg_device_get_reference_count(dev)); + EXPECT_EQ(devRefCntInit + 1, vkvg_device_get_reference_count(dev)); EXPECT_EQ(1, vkvg_surface_get_reference_count(surf)); vkvg_surface_reference(surf); - - EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); EXPECT_EQ(2, vkvg_surface_get_reference_count(surf)); - EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); vkvg_surface_destroy(surf); - - EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); EXPECT_EQ(1, vkvg_surface_get_reference_count(surf)); - EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf)); vkvg_surface_destroy(surf); - EXPECT_EQ(0, vkvg_surface_get_reference_count(surf)); + EXPECT_EQ(devRefCntInit, vkvg_device_get_reference_count(dev)); + //EXPECT_EQ(0, vkvg_surface_get_reference_count(surf)); +} +TEST_F(SurfaceTest, SurfProperties) { + EXPECT_EQ(0, vkvg_surface_get_width(NULL)); + EXPECT_EQ(0, vkvg_surface_get_height(NULL)); + EXPECT_EQ(NULL, vkvg_surface_get_vk_image(NULL)); + EXPECT_EQ(VK_FORMAT_UNDEFINED, vkvg_surface_get_vk_format(NULL)); + + VkvgSurface surf = vkvg_surface_create(dev, 512, 256); + EXPECT_EQ(512, vkvg_surface_get_width(surf)); + EXPECT_EQ(256, vkvg_surface_get_height(surf)); + EXPECT_EQ(VK_FORMAT_B8G8R8A8_UNORM, vkvg_surface_get_vk_format(surf)); + EXPECT_NE(nullptr, vkvg_surface_get_vk_image(surf)); + + vkvg_surface_destroy(surf); +} +TEST_F(SurfaceTest, SurfWrite) { + EXPECT_EQ(VKVG_STATUS_INVALID_STATUS, vkvg_surface_write_to_memory(NULL, NULL)); + EXPECT_EQ(VKVG_STATUS_INVALID_STATUS, vkvg_surface_write_to_png(NULL, NULL)); + const uint32_t imgSize = 8; + VkvgSurface surf = vkvg_surface_create(dev, imgSize, imgSize); + EXPECT_EQ(VKVG_STATUS_WRITE_ERROR, vkvg_surface_write_to_memory(surf, NULL)); + EXPECT_EQ(VKVG_STATUS_WRITE_ERROR, vkvg_surface_write_to_png(surf, NULL)); + uint32_t buff[imgSize*imgSize]; + EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_write_to_memory(surf, (unsigned char*)buff)); + + vkvg_surface_destroy(surf); +} + +TEST_F(SurfaceTest, SurfClear) { + const uint32_t imgSize = 8; + VkvgSurface surf = vkvg_surface_create(dev, imgSize, imgSize); + VkvgContext ctx = vkvg_create(surf); + vkvg_set_source_rgb(ctx, 1, 0, 0); + vkvg_paint(ctx); + vkvg_destroy(ctx); + + vkvg_surface_clear(surf); + + checkPixels(surf, 0x00000000); + vkvg_surface_destroy(surf); } diff --git a/tests/data/compassion-chineese-small.gif b/tests/data/compassion-chineese-small.gif new file mode 100644 index 0000000..431a6de Binary files /dev/null and b/tests/data/compassion-chineese-small.gif differ diff --git a/tests/data/miroir2-64.png b/tests/data/miroir2-64.png new file mode 100644 index 0000000..8e32479 Binary files /dev/null and b/tests/data/miroir2-64.png differ diff --git a/tests/data/miroir2.png b/tests/data/miroir2.png new file mode 100644 index 0000000..67ca209 Binary files /dev/null and b/tests/data/miroir2.png differ