/*

 * Copyright (c) 2012-2017 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "test_engine/test.h"
#include <VX/vx.h>
#include <VX/vxu.h>
#include <string.h>

#if defined OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION

TESTCASE(SmokeTest, CT_VXContext, ct_setup_vx_context, 0)

typedef struct _mystruct {
    vx_uint32 some_uint;
    vx_float64 some_double;
} mystruct;

TEST(SmokeTest, test_vxRegisterUserStruct)
{
    vx_context context = context_->vx_context_;
    vx_enum mytype = 0;
    vx_array array = 0;
    vx_enum type = 0;
    vx_size sz = 0;

    mytype = vxRegisterUserStruct(context, sizeof(mystruct));
    ASSERT(mytype >= VX_TYPE_USER_STRUCT_START);

    ASSERT_VX_OBJECT(array = vxCreateArray(context, mytype, 10), VX_TYPE_ARRAY);

    VX_CALL(vxQueryArray(array, VX_ARRAY_ITEMTYPE, &type, sizeof(type)));
    ASSERT_EQ_INT(mytype, type);

    VX_CALL(vxQueryArray(array, VX_ARRAY_ITEMSIZE, &sz, sizeof(sz)));
    ASSERT_EQ_INT(sizeof(mystruct), sz);

    VX_CALL(vxReleaseArray(&array));
    ASSERT(array == 0);
}


TEST(SmokeTest, test_vxHint)
{
    vx_image image = 0;
    vx_graph graph = 0;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);

//    VX_CALL(vxHint((vx_reference)image, VX_HINT_SERIALIZE, 0, 0));
//    VX_CALL(vxHint((vx_reference)graph, VX_HINT_SERIALIZE, 0, 0));
//    VX_CALL(vxHint((vx_reference)context, VX_HINT_SERIALIZE, 0, 0));

    VX_CALL(vxReleaseImage(&image));
    VX_CALL(vxReleaseGraph(&graph));

    ASSERT_EQ_PTR(0, image);
    ASSERT_EQ_PTR(0, graph);
}


TEST(SmokeTest, test_vxReleaseReference)
{
    vx_context context = context_->vx_context_;
    vx_uint32 ref_count0 = 0;
    vx_uint32 ref_count1 = 0;
    vx_reference ref = 0;

    {
        /* test node reference */
        vx_graph graph = 0;
        vx_node node = 0;
        vx_image src1 = 0;
        vx_image src2 = 0;
        vx_image dst = 0;
        EXPECT_VX_OBJECT(src1 = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        EXPECT_VX_OBJECT(src2 = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        EXPECT_VX_OBJECT(dst  = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        EXPECT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
        EXPECT_VX_OBJECT(node = vxAddNode(graph, src1, src2, VX_CONVERT_POLICY_WRAP, dst), VX_TYPE_NODE);
        ref = (vx_reference)node;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)node;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseImage(&src1));
        VX_CALL(vxReleaseImage(&src2));
        VX_CALL(vxReleaseImage(&dst));
        VX_CALL(vxReleaseNode(&node));
        VX_CALL(vxReleaseGraph(&graph));
    }

    {
        /* test array reference */
        vx_array array = 0;
        EXPECT_VX_OBJECT(array = vxCreateArray(context, VX_TYPE_KEYPOINT, 32), VX_TYPE_ARRAY);
        ref = (vx_reference)array;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)array;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseArray(&array));
    }

    {
        /* test convolution reference */
        vx_convolution convolution = 0;
        EXPECT_VX_OBJECT(convolution = vxCreateConvolution(context, 5, 5), VX_TYPE_CONVOLUTION);
        ref = (vx_reference)convolution;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)convolution;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseConvolution(&convolution));
    }

    {
        /* test distribution reference */
        vx_distribution distribution = 0;
        EXPECT_VX_OBJECT(distribution = vxCreateDistribution(context, 32, 0, 255), VX_TYPE_DISTRIBUTION);
        ref = (vx_reference)distribution;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)distribution;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseDistribution(&distribution));
    }

    {
        /* test image reference */
        vx_image image = 0;
        EXPECT_VX_OBJECT(image = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        ref = (vx_reference)image;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)image;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseImage(&image));
    }

    {
        /* test LUT reference */
        vx_lut lut = 0;
        EXPECT_VX_OBJECT(lut = vxCreateLUT(context, VX_TYPE_UINT8, 127), VX_TYPE_LUT);
        ref = (vx_reference)lut;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)lut;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseLUT(&lut));
    }

    {
        /* test matrix reference */
        vx_matrix matrix = 0;
        EXPECT_VX_OBJECT(matrix = vxCreateMatrix(context, VX_TYPE_FLOAT32, 32, 32), VX_TYPE_MATRIX);
        ref = (vx_reference)matrix;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)matrix;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseMatrix(&matrix));
    }

    {
        /* test pyramid reference */
        vx_pyramid pyramid = 0;
        EXPECT_VX_OBJECT(pyramid = vxCreatePyramid(context, 3, VX_SCALE_PYRAMID_HALF, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_PYRAMID);
        ref = (vx_reference)pyramid;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)pyramid;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleasePyramid(&pyramid));
    }

    {
        /* test remap reference */
        vx_remap remap = 0;
        EXPECT_VX_OBJECT(remap = vxCreateRemap(context, 320, 240, 160, 120), VX_TYPE_REMAP);
        ref = (vx_reference)remap;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)remap;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseRemap(&remap));
    }

    {
        /* test scalar reference */
        vx_scalar scalar = 0;
        vx_uint32 val = 5;
        EXPECT_VX_OBJECT(scalar = vxCreateScalar(context, VX_TYPE_UINT32, &val), VX_TYPE_SCALAR);
        ref = (vx_reference)scalar;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)scalar;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseScalar(&scalar));
    }

    {
        /* test threshold reference */
        vx_threshold threshold = 0;
        EXPECT_VX_OBJECT(threshold = vxCreateThresholdForImage(context, VX_THRESHOLD_TYPE_BINARY, VX_DF_IMAGE_U8, VX_DF_IMAGE_U8), VX_TYPE_THRESHOLD);
        ref = (vx_reference)threshold;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)threshold;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseThreshold(&threshold));
    }

    {
        /* test delay reference */
        vx_delay delay = 0;
        vx_image exemplar = 0;
        EXPECT_VX_OBJECT(exemplar = vxCreateImage(context, 320, 240, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
        EXPECT_VX_OBJECT(delay = vxCreateDelay(context, (vx_reference)exemplar, 5), VX_TYPE_DELAY);
        ref = (vx_reference)delay;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)delay;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseImage(&exemplar));
        VX_CALL(vxReleaseDelay(&delay));
    }

    {
        /* test kernel reference */
        vx_kernel kernel = 0;
        EXPECT_VX_OBJECT(kernel = vxGetKernelByEnum(context, VX_KERNEL_ADD), VX_TYPE_KERNEL);
        ref = (vx_reference)kernel;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)kernel;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseKernel(&kernel));
    }

    {
        /* test parameter reference */
        vx_kernel kernel = 0;
        vx_parameter parameter = 0;
        EXPECT_VX_OBJECT(kernel = vxGetKernelByEnum(context, VX_KERNEL_ADD), VX_TYPE_KERNEL);
        EXPECT_VX_OBJECT(parameter = vxGetKernelParameterByIndex(kernel, 0), VX_TYPE_PARAMETER);
        ref = (vx_reference)parameter;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)parameter;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseKernel(&kernel));
        VX_CALL(vxReleaseParameter(&parameter));
    }

}


TEST(SmokeTest, test_vxRetainReference)
{
    vx_image image = 0;
    vx_reference image_ref = 0;
    vx_uint32 image_count = 0;
    vx_context context = context_->vx_context_;
    vx_uint32 num_refs1 = 0, num_refs2 = 0, num_refs3 = 0, num_refs4 = 0;

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs1, sizeof(num_refs1)), VX_SUCCESS);

    ASSERT_VX_OBJECT(image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs2, sizeof(num_refs2)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs2, num_refs1+1);

    image_ref = (vx_reference)image;
    ASSERT_EQ_VX_STATUS(vxQueryReference(image_ref, VX_REFERENCE_COUNT, (void*)&image_count, sizeof(image_count)), VX_SUCCESS);
    ASSERT_EQ_INT(image_count, 1);

    image_ref = (vx_reference)image;
    VX_CALL(vxRetainReference(image_ref));

    image_ref = (vx_reference)image;
    ASSERT_EQ_VX_STATUS(vxQueryReference(image_ref, VX_REFERENCE_COUNT, (void*)&image_count, sizeof(image_count)), VX_SUCCESS);
    ASSERT_EQ_INT(image_count, 2);

    image_ref = (vx_reference)image;
    VX_CALL(vxReleaseReference(&image_ref));

    ASSERT_EQ_PTR(0, image_ref);

    image_ref = (vx_reference)image;
    ASSERT_EQ_VX_STATUS(vxQueryReference(image_ref, VX_REFERENCE_COUNT, (void*)&image_count, sizeof(image_count)), VX_SUCCESS);
    ASSERT_EQ_INT(image_count, 1);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs3, sizeof(num_refs3)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs3, num_refs1+1);

    image_ref = (vx_reference)image;
    VX_CALL(vxReleaseReference(&image_ref));

    ASSERT_EQ_PTR(0, image_ref);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs4, sizeof(num_refs4)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs4, num_refs1);
}

TEST(SmokeTest, test_vxSetParameterByIndex)
{
    vx_context context = context_->vx_context_;

    vx_enum kernel_id = VX_KERNEL_SOBEL_3x3; /* params: 0:req 1:opt 2:opt */
    vx_graph graph = NULL;
    vx_kernel kernel = NULL;
    vx_node node = NULL;
    vx_uint32 width = 32, height = 32;
    vx_image image = NULL;
    vx_image dy = NULL;
    vx_uint32 node_parameters = 0;
    vx_uint32 i;

    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(kernel = vxGetKernelByEnum(context, kernel_id), VX_TYPE_KERNEL);
    ASSERT_VX_OBJECT(node = vxCreateGenericNode(graph, kernel), VX_TYPE_NODE);
    ASSERT_VX_OBJECT(image = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dy = vxCreateImage(context, width, height, VX_DF_IMAGE_S16), VX_TYPE_IMAGE);

    VX_CALL(vxQueryNode(node, VX_NODE_PARAMETERS, &node_parameters, sizeof(node_parameters)));

    // 1. check that vxCreateGenericNode sets all params to NULL
    for (i = 0; i < node_parameters; ++i)
    {
        vx_parameter param = NULL;
        vx_reference ref = NULL;

        ASSERT_VX_OBJECT(param = vxGetParameterByIndex(node, i), VX_TYPE_PARAMETER);

        VX_CALL(vxQueryParameter(param, VX_PARAMETER_REF, &ref, sizeof(ref)));
        ASSERT(ref == NULL);

        VX_CALL(vxReleaseParameter(&param));
    }

    // 2. check that vxSetParameterByIndex failed to set required params to NULL
    ASSERT(node_parameters == 3);
    ASSERT_NE_VX_STATUS(VX_SUCCESS, vxSetParameterByIndex(node, 0, (vx_reference)NULL)); // required parameter
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetParameterByIndex(node, 1, (vx_reference)NULL)); // output images are optional
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetParameterByIndex(node, 2, (vx_reference)dy)); // (but at least one should specified)

    // 3. check that vxVerifyGraph does not allow required params to be NULL
    ASSERT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph));
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxSetParameterByIndex(node, 0, (vx_reference)image));
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph));

    VX_CALL(vxReleaseImage(&image));
    VX_CALL(vxReleaseImage(&dy));
    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseKernel(&kernel));
    VX_CALL(vxReleaseGraph(&graph));
}

TEST(SmokeTest, test_vxSetParameterByReference)
{
    vx_context context = context_->vx_context_;
    vx_image src_image = 0, dst_image = 0;
    vx_graph graph = 0;
    vx_kernel kernel = 0;
    vx_node node = 0;
    vx_uint32 num_params = 0;
    vx_parameter parameter = 0;
    vx_image p_image = 0;

    ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(kernel = vxGetKernelByEnum(context, VX_KERNEL_BOX_3x3), VX_TYPE_KERNEL);
    VX_CALL(vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &num_params, sizeof(num_params)));
    ASSERT_EQ_INT(2, num_params);
    ASSERT_VX_OBJECT(node = vxCreateGenericNode(graph, kernel), VX_TYPE_NODE);
    VX_CALL(vxSetParameterByIndex(node, 0, (vx_reference)src_image));

    ASSERT_VX_OBJECT(parameter = vxGetParameterByIndex(node, 0), VX_TYPE_PARAMETER);
    VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
    ASSERT(p_image == src_image);
    VX_CALL(vxReleaseImage(&p_image));
    VX_CALL(vxReleaseParameter(&parameter));

    ASSERT_VX_OBJECT(parameter = vxGetParameterByIndex(node, 1), VX_TYPE_PARAMETER);
    VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
    ASSERT(p_image != dst_image);
    VX_CALL(vxSetParameterByReference(parameter, (vx_reference)dst_image));
    VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
    ASSERT(p_image == dst_image);

    VX_CALL(vxReleaseImage(&p_image));
    VX_CALL(vxReleaseParameter(&parameter));
    VX_CALL(vxVerifyGraph(graph));
    VX_CALL(vxProcessGraph(graph));
    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseKernel(&kernel));
    VX_CALL(vxReleaseGraph(&graph));
    VX_CALL(vxReleaseImage(&dst_image));
    VX_CALL(vxReleaseImage(&src_image));

    ASSERT(node == 0);
    ASSERT(kernel == 0);
    ASSERT(graph == 0);
    ASSERT(dst_image == 0);
    ASSERT(src_image == 0);
}

TEST(SmokeTest, test_vxGetParameterByIndex)
{
    vx_context context = context_->vx_context_;
    vx_image src_image = 0;
    vx_graph graph = 0;
    vx_kernel kernel = 0;
    vx_node node = 0;
    vx_uint32 num_params = 0;
    vx_parameter parameter = 0;
    vx_image p_image = 0;

    ASSERT_VX_OBJECT(src_image = vxCreateImage(context, 128, 128, VX_DF_IMAGE_U8), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(kernel = vxGetKernelByEnum(context, VX_KERNEL_BOX_3x3), VX_TYPE_KERNEL);
    VX_CALL(vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &num_params, sizeof(num_params)));
    ASSERT_EQ_INT(2, num_params);
    ASSERT_VX_OBJECT(node = vxCreateGenericNode(graph, kernel), VX_TYPE_NODE);
    VX_CALL(vxSetParameterByIndex(node, 0, (vx_reference)src_image));

    ASSERT_VX_OBJECT(parameter = vxGetParameterByIndex(node, 0), VX_TYPE_PARAMETER);
    VX_CALL(vxQueryParameter(parameter, VX_PARAMETER_REF, &p_image, sizeof(p_image)));
    ASSERT(p_image == src_image);
    VX_CALL(vxReleaseImage(&p_image));
    VX_CALL(vxReleaseParameter(&parameter));

    VX_CALL(vxReleaseNode(&node));
    VX_CALL(vxReleaseKernel(&kernel));
    VX_CALL(vxReleaseGraph(&graph));
    VX_CALL(vxReleaseImage(&src_image));

    ASSERT(node == 0);
    ASSERT(kernel == 0);
    ASSERT(graph == 0);
    ASSERT(src_image == 0);
}

#endif //OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION


TESTCASE(SmokeTestBase, CT_VXContext, ct_setup_vx_context, 0)

TEST(SmokeTestBase, test_vxReleaseReferenceBase)
{
    vx_context context = context_->vx_context_;
    vx_uint32 ref_count0 = 0;
    vx_uint32 ref_count1 = 0;
    vx_reference ref = 0;

    {
        /* test context reference */
        ref = (vx_reference)context;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)context;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);
    }

    {
        /* test graph reference */
        vx_graph graph = 0;
        EXPECT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
        ref = (vx_reference)graph;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)graph;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseGraph(&graph));
    }

    {
        /* test graph reference */
        vx_graph graph = 0;
        EXPECT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
        ref = (vx_reference)graph;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)graph;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseGraph(&graph));
    }

    {
        /* test kernel reference */
        vx_kernel kernel = 0;
        VX_CALL(vxLoadKernels(context, "test-testmodule"));
        EXPECT_VX_OBJECT(kernel = vxGetKernelByName(context, "org.khronos.test.testmodule"), VX_TYPE_KERNEL);
        ref = (vx_reference)kernel;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)kernel;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseKernel(&kernel));
        VX_CALL(vxUnloadKernels(context, "test-testmodule"));
    }

    {
        /* test parameter reference */
        vx_kernel kernel = 0;
        vx_parameter parameter = 0;
        VX_CALL(vxLoadKernels(context, "test-testmodule"));
        EXPECT_VX_OBJECT(kernel = vxGetKernelByName(context, "org.khronos.test.testmodule"), VX_TYPE_KERNEL);
        EXPECT_VX_OBJECT(parameter = vxGetKernelParameterByIndex(kernel, 0), VX_TYPE_PARAMETER);
        ref = (vx_reference)parameter;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count0, sizeof(ref_count0)), VX_SUCCESS);
        VX_CALL(vxRetainReference(ref));
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 1);
        VX_CALL(vxReleaseReference(&ref));
        ref = (vx_reference)parameter;
        ref_count1 = 0;
        ASSERT_EQ_VX_STATUS(vxQueryReference(ref, VX_REFERENCE_COUNT, (void*)&ref_count1, sizeof(ref_count1)), VX_SUCCESS);
        ASSERT_EQ_INT(ref_count1 - ref_count0, 0);

        VX_CALL(vxReleaseKernel(&kernel));
        VX_CALL(vxReleaseParameter(&parameter));
        VX_CALL(vxUnloadKernels(context, "test-testmodule"));
    }

}

TEST(SmokeTestBase, test_vxLoadKernels)
{
    vx_context context = context_->vx_context_;
    vx_kernel kernel = 0;

    VX_CALL(vxLoadKernels(context, "test-testmodule"));
    EXPECT_VX_OBJECT(kernel = vxGetKernelByName(context, "org.khronos.test.testmodule"), VX_TYPE_KERNEL);
    VX_CALL(vxReleaseKernel(&kernel));
    VX_CALL(vxUnloadKernels(context, "test-testmodule"));
}


TEST(SmokeTestBase, test_vxUnloadKernels)
{
    vx_context context = context_->vx_context_;
    vx_kernel kernel = NULL;
    vx_int32 num_modules1;
    vx_int32 num_modules2;
    vx_int32 num_unique_kernels1;
    vx_int32 num_unique_kernels2;

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_MODULES, (void*)&num_modules1, sizeof(num_modules1)), VX_SUCCESS);
    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, (void*)&num_unique_kernels1, sizeof(num_unique_kernels1)), VX_SUCCESS);
    ASSERT(num_modules1 >= 0u);
    ASSERT(num_unique_kernels1 > 0u);

    kernel = vxGetKernelByName(context, "org.khronos.test.testmodule");
    ASSERT_NE_VX_STATUS(VX_SUCCESS, vxGetStatus((vx_reference)kernel));

    VX_CALL(vxLoadKernels(context, "test-testmodule"));
    ASSERT_VX_OBJECT(kernel = vxGetKernelByName(context, "org.khronos.test.testmodule"), VX_TYPE_KERNEL);
    VX_CALL(vxReleaseKernel(&kernel));

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_MODULES, (void*)&num_modules2, sizeof(num_modules1)), VX_SUCCESS);
    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, (void*)&num_unique_kernels2, sizeof(num_unique_kernels2)), VX_SUCCESS);
    ASSERT(num_modules2 > num_modules1);
    ASSERT(num_unique_kernels2 > num_unique_kernels1);

    VX_CALL(vxUnloadKernels(context, "test-testmodule"));

    kernel = vxGetKernelByName(context, "org.khronos.test.testmodule");
    ASSERT_NE_VX_STATUS(VX_SUCCESS, vxGetStatus((vx_reference)kernel));

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_MODULES, (void*)&num_modules2, sizeof(num_modules1)), VX_SUCCESS);
    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_UNIQUE_KERNELS, (void*)&num_unique_kernels2, sizeof(num_unique_kernels2)), VX_SUCCESS);
    ASSERT(num_modules2 == num_modules1);
    ASSERT(num_unique_kernels2 == num_unique_kernels1);
}

TEST(SmokeTestBase, test_vxSetReferenceName)
{
    vx_context context = context_->vx_context_;

    vx_graph graph = vxCreateGraph(context);
    const char* graph_name = "Graph";
    char* actual_name = NULL;

    VX_CALL(vxSetReferenceName((vx_reference)graph, graph_name));
    VX_CALL(vxQueryReference((vx_reference)graph, VX_REFERENCE_NAME, &actual_name, sizeof(actual_name)));

    ASSERT(0 == strcmp(graph_name, actual_name));

    VX_CALL(vxReleaseGraph(&graph));
}

TEST(SmokeTestBase, test_vxGetStatus)
{
    vx_context context = context_->vx_context_;
    vx_kernel kernel = NULL;
    vx_status status = VX_SUCCESS;

    status = vxGetStatus((vx_reference)kernel);
    ASSERT_EQ_INT(VX_ERROR_NO_RESOURCES, status);

    kernel = vxGetKernelByName(context, "org.khronos.test.testmodule");
    status = vxGetStatus((vx_reference)kernel);
    ASSERT_NE_VX_STATUS(VX_SUCCESS, status);

    kernel = vxGetKernelByName(context, "org.khronos.openvx.color_convert");
    status = vxGetStatus((vx_reference)kernel);
    ASSERT_EQ_INT(VX_SUCCESS, status);
}

TEST(SmokeTestBase, test_vxGetContext)
{
    vx_context context = context_->vx_context_;
    vx_kernel kernel = NULL;
    vx_context context_test = 0;

    context_test = vxGetContext((vx_reference)kernel);
    EXPECT_EQ_PTR(context_test, NULL);

    kernel = vxGetKernelByName(context, "org.khronos.openvx.color_convert");
    context_test = vxGetContext((vx_reference)kernel);
    ASSERT_VX_OBJECT(context_test, VX_TYPE_CONTEXT);
}

TEST(SmokeTestBase, test_vxQueryReference)
{
    vx_context context = context_->vx_context_;
    char* actual_name = NULL;
    vx_status status = VX_SUCCESS;
    vx_graph graph = 0;

    status = vxQueryReference((vx_reference)graph, VX_REFERENCE_NAME, &actual_name, sizeof(actual_name));
    ASSERT_EQ_INT(VX_ERROR_INVALID_REFERENCE, status);

    graph = vxCreateGraph(context);
    status = vxQueryReference((vx_reference)graph, VX_REFERENCE_COUNT, &actual_name, 3);
    ASSERT_EQ_INT(VX_ERROR_INVALID_PARAMETERS, status);
    status = vxQueryReference((vx_reference)graph, VX_REFERENCE_TYPE, &actual_name, 1);
    ASSERT_EQ_INT(VX_ERROR_INVALID_PARAMETERS, status);
    status = vxQueryReference((vx_reference)graph, VX_REFERENCE_NAME, NULL, 1);
    ASSERT_EQ_INT(VX_ERROR_INVALID_PARAMETERS, status);
    status = vxQueryReference((vx_reference)graph, VX_TYPE_REFERENCE, &actual_name, sizeof(actual_name));
    ASSERT_EQ_INT(VX_ERROR_NOT_SUPPORTED, status);

    VX_CALL(vxReleaseGraph(&graph));

}

TEST(SmokeTestBase, test_vxRetainReferenceBase)
{
    vx_graph graph = 0;
    vx_reference graph_ref = 0;
    vx_uint32 graph_count = 0;
    vx_context context = context_->vx_context_;
    vx_uint32 num_refs1 = 0, num_refs2 = 0, num_refs3 = 0, num_refs4 = 0;

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs1, sizeof(num_refs1)), VX_SUCCESS);

    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs2, sizeof(num_refs2)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs2, num_refs1 + 1);

    graph_ref = (vx_reference)graph;
    ASSERT_EQ_VX_STATUS(vxQueryReference(graph_ref, VX_REFERENCE_COUNT, (void*)&graph_count, sizeof(graph_count)), VX_SUCCESS);
    ASSERT_EQ_INT(graph_count, 1);

    graph_ref = (vx_reference)graph;
    VX_CALL(vxRetainReference(graph_ref));

    graph_ref = (vx_reference)graph;
    ASSERT_EQ_VX_STATUS(vxQueryReference(graph_ref, VX_REFERENCE_COUNT, (void*)&graph_count, sizeof(graph_count)), VX_SUCCESS);
    ASSERT_EQ_INT(graph_count, 2);

    graph_ref = (vx_reference)graph;
    VX_CALL(vxReleaseReference(&graph_ref));

    ASSERT_EQ_PTR(0, graph_ref);

    graph_ref = (vx_reference)graph;
    ASSERT_EQ_VX_STATUS(vxQueryReference(graph_ref, VX_REFERENCE_COUNT, (void*)&graph_count, sizeof(graph_count)), VX_SUCCESS);
    ASSERT_EQ_INT(graph_count, 1);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs3, sizeof(num_refs3)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs3, num_refs1 + 1);

    graph_ref = (vx_reference)graph;
    VX_CALL(vxReleaseReference(&graph_ref));

    ASSERT_EQ_PTR(0, graph_ref);

    ASSERT_EQ_VX_STATUS(vxQueryContext(context, VX_CONTEXT_REFERENCES, (void*)&num_refs4, sizeof(num_refs4)), VX_SUCCESS);
    ASSERT_EQ_INT(num_refs4, num_refs1);
}

#if defined OPENVX_USE_ENHANCED_VISION || OPENVX_CONFORMANCE_VISION

TESTCASE_TESTS(SmokeTest,
        test_vxRegisterUserStruct,
        test_vxHint,
        test_vxReleaseReference,
        test_vxRetainReference,
        test_vxSetParameterByIndex,
        test_vxSetParameterByReference,
        test_vxGetParameterByIndex
        )

#endif

TESTCASE_TESTS(SmokeTestBase,
        test_vxReleaseReferenceBase,
        test_vxLoadKernels,
        test_vxUnloadKernels,
        test_vxSetReferenceName,
        test_vxGetStatus,
        test_vxGetContext,
        test_vxQueryReference,
        test_vxRetainReferenceBase
        )