separate CMake option for VK debug utils, random curves tests

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0466c58f6ed18b03dde23d83b75374dcdbbb0e91..2212ce788b6024c9c75491bc8e0852f000ffb037 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,6 +31,7 @@ ENDIF()
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        ADD_DEFINITIONS (-DDEBUG)
        OPTION(ENABLE_VALIDATION "enable vulkan validation layer" ON)
+       OPTION(ENABLE_DBG_UTILS "enable VK_EXT_debug_utils extension" ON)
        OPTION(ENABLE_WIRED_FILL "enable wired polygon draw to check vertices and primitives" OFF)
        IF (UNIX)
                SET(CMAKE_${LANG}_FLAGS "-Wall -Wno-extra -Wno-unknown-pragmas -Wno-missing-braces -Wno-unused-variable")
@@ -39,6 +40,7 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        ENDIF()
 ELSE()
        UNSET(ENABLE_VALIDATION CACHE)
+       UNSET(ENABLE_DBG_UTILS CACHE)
        UNSET(ENABLE_WIRED_FILL CACHE)
        IF (UNIX)
                SET(CMAKE_${LANG}_FLAGS "-w")
@@ -83,6 +85,10 @@ ENDIF ()
 IF (ENABLE_WIRED_FILL)
        ADD_DEFINITIONS (-DVKVG_WIRED_DEBUG)
 ENDIF ()
+IF (ENABLE_DBG_UTILS)
+       ADD_DEFINITIONS (-DVKVG_DBG_UTILS)
+ENDIF ()
+
 
 FIND_PACKAGE(Vulkan REQUIRED)
 FIND_PACKAGE(Freetype REQUIRED)
@@ -169,7 +175,7 @@ FUNCTION (setup_lib LibName)
        SET_TARGET_PROPERTIES(${LibName} PROPERTIES
                        OUTPUT_NAME ${PROJECT_NAME}
                        VERSION ${vkvg_VERSION_MAJOR}.${vkvg_VERSION_MINOR}
-                       SOVERSION ${vkvg_VERSION_MAJOR}                 
+                       SOVERSION ${vkvg_VERSION_MAJOR}
                        C_STANDARD 99
                        C_EXTENSIONS OFF
                        PUBLIC_HEADER "include/vkvg.h;include/vkvg-nsvg.h"
@@ -220,6 +226,11 @@ ENDIF ()
 IF (VKVG_TEST_OFFSCREEN)
        MESSAGE(STATUS "Offscreen\t\t= true.")
 ENDIF ()
+IF (ENABLE_DBG_UTILS)
+       MESSAGE(STATUS "Debug utils\t\t= enabled.")
+ELSE ()
+       MESSAGE(STATUS "Debug utils\t\t= disabled.")
+ENDIF ()
 IF (ENABLE_VALIDATION)
        MESSAGE(STATUS "Validation\t\t= enabled.")
 ELSE ()

diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index a8f75d292e0750815fd8f25b6be4f4811fb6c4c2..e9bdf885110db16a75d649679a78139955b2edea 100644 (file)
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -140,7 +140,7 @@ VkvgContext vkvg_create(VkvgSurface surf)
 
        LOG(VKVG_LOG_DBG_ARRAYS, "INIT\tctx = %p; pathes:%ju pts:%ju vch:%d vbo:%d ich:%d ibo:%d\n", ctx, (uint64_t)ctx->sizePathes, (uint64_t)ctx->sizePoints, ctx->sizeVertices, ctx->sizeVBO, ctx->sizeIndices, ctx->sizeIBO);
 
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_COMMAND_POOL, (uint64_t)ctx->cmdPool, "CTX Cmd Pool");
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)ctx->cmdBuffers[0], "CTX Cmd Buff A");
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)ctx->cmdBuffers[1], "CTX Cmd Buff B");
@@ -274,7 +274,7 @@ void vkvg_close_path (VkvgContext ctx){
        //check if at least 3 points are present
        if (ctx->pathes[ctx->pathPtr] < 3)
                return;
-       
+
        //prevent closing on the same point
        if (vec2_equ(ctx->points[ctx->pointCount-1],
                                 ctx->points[ctx->pointCount - ctx->pathes[ctx->pathPtr]]))

diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c
index f43e307a5d70e6ebff28362ae65c8adf32b4baff..e2c0171f12038eb711607956ca41db7c1c6d5659 100644 (file)
--- a/src/vkvg_context_internal.c
+++ b/src/vkvg_context_internal.c
@@ -419,7 +419,7 @@ void _flush_vertices_caches (VkvgContext ctx) {
 void _end_render_pass (VkvgContext ctx) {
        LOG(VKVG_LOG_INFO, "END RENDER PASS: ctx = %p;\n", ctx);
        CmdEndRenderPass      (ctx->cmd);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_cmd_label_end (ctx->cmd);
 #endif
        ctx->renderPassBeginInfo.renderPass = ctx->pSurf->dev->renderPass;
@@ -516,7 +516,7 @@ void _start_cmd_for_render_pass (VkvgContext ctx) {
                                                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
        }
 
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_cmd_label_start(ctx->cmd, "ctx render pass", LAB_COLOR_RP);
 #endif
 
@@ -1182,7 +1182,6 @@ void _fill_ec (VkvgContext ctx){
                        ptrPath++;
                free (ecps);
        }
-       //_record_draw_cmd(ctx);
 }
 
 static const uint32_t one = 1;

diff --git a/src/vkvg_device.c b/src/vkvg_device.c
index 4388ed9b2d90c301d54e247d2f91f722c5ed208f..6f94cf550a2ba7e8a8afac44617686ab739d539d 100644 (file)
--- a/src/vkvg_device.c
+++ b/src/vkvg_device.c
@@ -115,7 +115,7 @@ VkvgDevice vkvg_device_create_multisample(VkInstance inst, VkPhysicalDevice phy,
 
        dev->references = 1;
 
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_COMMAND_POOL, (uint64_t)dev->cmdPool, "Device Cmd Pool");
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)dev->cmd, "Device Cmd Buff");
        vkh_device_set_object_name((VkhDevice)dev, VK_OBJECT_TYPE_FENCE, (uint64_t)dev->fence, "Device Fence");

diff --git a/src/vkvg_device_internal.c b/src/vkvg_device_internal.c
index ae4ba4f18bf1a9929b0f14e45f7866402d2a4903..55b5050d28f0da630593944198ba9d294c27f542 100644 (file)
--- a/src/vkvg_device_internal.c
+++ b/src/vkvg_device_internal.c
@@ -412,7 +412,7 @@ void _submit_cmd (VkvgDevice dev, VkCommandBuffer* cmd, VkFence fence) {
 }
 
 bool _init_function_pointers (VkvgDevice dev) {
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        if (vkGetInstanceProcAddr(dev->instance, "vkSetDebugUtilsObjectNameEXT")==VK_NULL_HANDLE){
                LOG(VKVG_LOG_ERR, "vkvg create device failed: 'VK_EXT_debug_utils' has to be loaded for Debug build\n");
                return false;

diff --git a/src/vkvg_surface.c b/src/vkvg_surface.c
index cc3b57be324b9fe43fc7ccf94a0d58da2a60b59f..b622653bcbf16f7376549cd1053b415b42023116 100644 (file)
--- a/src/vkvg_surface.c
+++ b/src/vkvg_surface.c
@@ -113,7 +113,7 @@ void _create_surface_main_image (VkvgSurface surf){
        surf->img = vkh_image_create((VkhDevice)surf->dev,surf->format,surf->width,surf->height,surf->tiling,VMA_MEMORY_USAGE_GPU_ONLY,
                                                                         VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT);
        vkh_image_create_descriptor(surf->img, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, VK_FILTER_NEAREST, VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_image_set_name(surf->img, "SURF main color");
        vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)vkh_image_get_view(surf->img), "SURF main color VIEW");
        vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_SAMPLER, (uint64_t)vkh_image_get_sampler(surf->img), "SURF main color SAMPLER");
@@ -126,7 +126,7 @@ void _create_surface_secondary_images (VkvgSurface surf) {
                                                                                  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
                vkh_image_create_descriptor(surf->imgMS, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, VK_FILTER_NEAREST,
                                                                        VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
                vkh_image_set_name(surf->imgMS, "SURF MS color IMG");
                vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)vkh_image_get_view(surf->imgMS), "SURF MS color VIEW");
                vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_SAMPLER, (uint64_t)vkh_image_get_sampler(surf->imgMS), "SURF MS color SAMPLER");
@@ -135,7 +135,7 @@ void _create_surface_secondary_images (VkvgSurface surf) {
        surf->stencil = vkh_image_ms_create((VkhDevice)surf->dev,FB_STENCIL_FORMAT,surf->dev->samples,surf->width,surf->height,VMA_MEMORY_USAGE_GPU_ONLY,                                     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
        vkh_image_create_descriptor(surf->stencil, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_STENCIL_BIT, VK_FILTER_NEAREST,
                                                                VK_FILTER_NEAREST, VK_SAMPLER_MIPMAP_MODE_NEAREST,VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_image_set_name(surf->stencil, "SURF stencil");
        vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t)vkh_image_get_view(surf->stencil), "SURF stencil VIEW");
        vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_SAMPLER, (uint64_t)vkh_image_get_sampler(surf->stencil), "SURF stencil SAMPLER");
@@ -161,7 +161,7 @@ void _create_framebuffer (VkvgSurface surf) {
                frameBufferCreateInfo.attachmentCount = 2;
        }
        VK_CHECK_RESULT(vkCreateFramebuffer(surf->dev->vkDev, &frameBufferCreateInfo, NULL, &surf->fb));
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_device_set_object_name((VkhDevice)surf->dev, VK_OBJECT_TYPE_FRAMEBUFFER, (uint64_t)surf->fb, "SURF FB");
 #endif
 }

diff --git a/tests/circles.c b/tests/circles.c
index 9dd31cc76f388fe56bfbfaef3bb058ffebb3b54f..dbc86f93fb1ceb9b7f2f917de8656ddb90f116c6 100644 (file)
--- a/tests/circles.c
+++ b/tests/circles.c
@@ -56,7 +56,7 @@ void sizes() {
 
 int main(int argc, char *argv[]) {
        PERFORM_TEST (fill_and_stroke, argc, argv);
-       //PERFORM_TEST (sizes, argc, argv);
-       //PERFORM_TEST (scaled_up, argc, argv);
+       PERFORM_TEST (sizes, argc, argv);
+       PERFORM_TEST (scaled_up, argc, argv);
        return 0;
 }

diff --git a/tests/common/test.c b/tests/common/test.c
index d879fbb1e6071b3dda9fc4872eb79216e52c1dda..bd283166aec6fd410aba39123f8eccad3b2a27bd 100644 (file)
--- a/tests/common/test.c
+++ b/tests/common/test.c
@@ -33,8 +33,8 @@ bool mouseDown = false;
 VkvgDevice device      = NULL;
 VkvgSurface surf       = NULL;
 
-uint32_t test_size     = 500;  // items drawn in one run, or complexity
-uint32_t iterations    = 500;// repeat test n times
+uint32_t test_size     = 100;  // items drawn in one run, or complexity
+uint32_t iterations    = 1000;// repeat test n times
 uint32_t test_width    = 1024;
 uint32_t test_height= 768;
 bool    test_vsync = false;
@@ -194,13 +194,13 @@ void perform_test_offscreen (void(*testfunc)(void), const char *testName, int ar
        const uint32_t enabledLayersCount = 0;
        const char* enabledLayers[] = {NULL};
 #endif
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        enabledExts[enabledExtsCount] = "VK_EXT_debug_utils";
        enabledExtsCount++;
 #endif
 
        VkhApp app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_app_enable_debug_messenger(app
                                                                   , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
                                                                   | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT

diff --git a/tests/common/vkengine.c b/tests/common/vkengine.c
index 287e8b72a210f9faf223db57de31a582acaf80e4..7d9555f6999d961637267b32d2ad4e2ba760f94d 100644 (file)
--- a/tests/common/vkengine.c
+++ b/tests/common/vkengine.c
@@ -116,22 +116,22 @@ vk_engine_t* vkengine_create (VkPhysicalDeviceType preferedGPU, VkPresentModeKHR
        const uint32_t enabledLayersCount = 0;
        const char* enabledLayers[] = {NULL};
 #endif
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        enabledExts[enabledExtsCount] = "VK_EXT_debug_utils";
        enabledExtsCount++;
 #endif
 
 
        e->app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts);
-#ifdef DEBUG
+#if defined(DEBUG) && defined (VKVG_DBG_UTILS)
        vkh_app_enable_debug_messenger(e->app
-                                                                  , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
-                                                                  | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
-                                                                  | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+                                                                  , VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
+                                                                  //| VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
+                                                                  //| VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
                                                                   , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
-                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
-                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
-                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
+                                                                  //cma| VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
+                                                                  //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
+                                                                  //| VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
                                                                   , NULL);
 #endif
 
@@ -196,7 +196,7 @@ vk_engine_t* vkengine_create (VkPhysicalDeviceType preferedGPU, VkPresentModeKHR
 }
 
 void vkengine_destroy (VkEngine e) {
-       vkDeviceWaitIdle(e->dev->dev);
+       //vkDeviceWaitIdle(e->dev->dev);
 
        VkSurfaceKHR surf = e->renderer->surface;
 
@@ -206,10 +206,10 @@ void vkengine_destroy (VkEngine e) {
        vkh_device_destroy (e->dev);
 
        glfwDestroyWindow (e->window);
-       glfwTerminate ();
-
        vkh_app_destroy (e->app);
 
+       glfwTerminate ();
+
        free(e);
 }
 void vkengine_close (VkEngine e) {

diff --git a/tests/curve.c b/tests/curve.c
index bdeaf5a2336cf8a9ff14b40d0589b15803e4d126..2a76693ff73670a450b29f7cfb47c981d231e206 100644 (file)
--- a/tests/curve.c
+++ b/tests/curve.c
@@ -33,13 +33,15 @@ void test(){
        vkvg_translate(ctx,400,30);
 
        */
+       //vkvg_set_fill_rule(ctx,VKVG_FILL_RULE_EVEN_ODD);
        vkvg_translate(ctx,200,30);
        vkvg_arc(ctx, 200, 200, 20, 0, M_PIF*2);
        //vkvg_stroke(ctx);
 
-       vkvg_set_source_rgba   (ctx, 0.5f,0.0f,1.0f,0.5f);
+       vkvg_set_source_rgba (ctx, 0.5f,0.0f,1.0f,0.5f);
        vkvg_move_to(ctx,100,100);
        vkvg_line_to(ctx,200,100);
+       //vkvg_move_to(ctx,200,100);
        vkvg_curve_to(ctx,250,100,300,150,300,200);
        vkvg_line_to(ctx,300,300);
        vkvg_curve_to(ctx,300,350,250,400,200,400);
@@ -47,6 +49,7 @@ void test(){
        vkvg_curve_to(ctx,50,400,10,350,10,300);
        vkvg_line_to(ctx,10,200);
        vkvg_curve_to(ctx,10,150,50,100,100,100);
+       //vkvg_close_path(ctx);
        vkvg_fill_preserve(ctx);
        vkvg_set_source_rgba   (ctx, 0.1f,0.3f,0.7f,0.5f);
        vkvg_stroke(ctx);
@@ -66,7 +69,6 @@ void curved_rect() {
        vkvg_set_line_width(ctx, 15);
        vkvg_set_source_rgba(ctx, 0, 0.5f, 0.4f, 1);
 
-
        if ((radius > height / 2) || (radius > width / 2))
                radius = MIN(height / 2, width / 2);
 
@@ -105,9 +107,91 @@ void test2() {
 
        vkvg_destroy(ctx);
 }
+
+static float line_width = 1.f;
+static vkvg_line_cap_t line_cap = VKVG_LINE_CAP_ROUND;
+static vkvg_fill_rule_t fill_rule = VKVG_FILL_RULE_NON_ZERO;
+static bool fillAndStroke = true;
+
+void _rnd_curve (VkvgContext ctx) {
+       float w = (float)test_width;
+       float h = (float)test_height;
+
+       float x2 = w*rand()/RAND_MAX;
+       float y2 = h*rand()/RAND_MAX;
+       float cp_x1 = w*rand()/RAND_MAX;
+       float cp_y1 = h*rand()/RAND_MAX;
+       float cp_x2 = w*rand()/RAND_MAX;
+       float cp_y2 = h*rand()/RAND_MAX;
+
+       vkvg_curve_to(ctx, cp_x1, cp_y1, cp_x2, cp_y2, x2, y2);
+}
+
+
+void random_curves () {
+       float w = (float)test_width;
+       float h = (float)test_height;
+
+       VkvgContext ctx = vkvg_create(surf);
+       vkvg_clear(ctx);
+       vkvg_set_line_width (ctx,line_width);
+       vkvg_set_line_cap(ctx, line_cap);
+
+       for (uint32_t i=0; i<test_size; i++) {
+               randomize_color(ctx);
+               float x1 = w*rand()/RAND_MAX;
+               float y1 = h*rand()/RAND_MAX;
+
+               vkvg_move_to (ctx, x1, y1);
+               _rnd_curve(ctx);
+
+               vkvg_stroke (ctx);
+       }
+       vkvg_destroy(ctx);
+}
+void single_long_line_curved () {
+       float w = (float)test_width;
+       float h = (float)test_height;
+
+       VkvgContext ctx = vkvg_create(surf);
+       vkvg_clear(ctx);
+       vkvg_set_line_width (ctx,line_width);
+       vkvg_set_line_cap(ctx, line_cap);
+       vkvg_set_fill_rule(ctx, fill_rule);
+
+       randomize_color(ctx);
+       float x1 = w*rand()/RAND_MAX;
+       float y1 = h*rand()/RAND_MAX;
+       vkvg_move_to (ctx, x1, y1);
+
+       for (uint32_t i=0; i<test_size; i++) {
+               _rnd_curve(ctx);
+       }
+
+       if (fillAndStroke) {
+               vkvg_fill_preserve(ctx);
+               randomize_color(ctx);
+               vkvg_stroke (ctx);
+       }else
+               vkvg_fill (ctx);
+
+       vkvg_destroy(ctx);
+}
 int main(int argc, char *argv[]) {
        PERFORM_TEST(test, argc, argv);
        PERFORM_TEST(test2, argc, argv);
        PERFORM_TEST(curved_rect, argc, argv);
+       fillAndStroke = false;
+       fill_rule = VKVG_FILL_RULE_NON_ZERO;
+       PERFORM_TEST(single_long_line_curved, argc, argv);
+       fill_rule = VKVG_FILL_RULE_EVEN_ODD;
+       PERFORM_TEST(single_long_line_curved, argc, argv);
+       fillAndStroke = true;
+       fill_rule = VKVG_FILL_RULE_NON_ZERO;
+       PERFORM_TEST(single_long_line_curved, argc, argv);
+       fill_rule = VKVG_FILL_RULE_EVEN_ODD;
+       PERFORM_TEST(single_long_line_curved, argc, argv);
+
+       PERFORM_TEST(random_curves, argc, argv);
        return 0;
 }