/* 

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

//#define CT_EXECUTE_ASYNC

static void referenceAdd(CT_Image src0, CT_Image src1, CT_Image dst, enum vx_convert_policy_e policy)
{
    int32_t min_bound, max_bound;
    uint32_t i, j;
    ASSERT(src0 && src1 && dst);
    ASSERT(src0->width = src1->width && src0->width == dst->width);
    ASSERT(src0->height = src1->height && src0->height == dst->height);

    switch (policy)
    {
        case VX_CONVERT_POLICY_SATURATE:
            if (dst->format == VX_DF_IMAGE_U8)
            {
                min_bound = 0;
                max_bound = 255;
            }
            else if (dst->format == VX_DF_IMAGE_S16)
            {
                min_bound = -32768;
                max_bound =  32767;
            }
            else
                FAIL("Unsupported result format: (%.4s)", &dst->format);
            break;
        case VX_CONVERT_POLICY_WRAP:
            min_bound = INT32_MIN;
            max_bound = INT32_MAX;
            break;
        default: FAIL("Unknown owerflow policy"); break;
    };

#define ADD_LOOP(s0, s1, r)                                                                                     \
    do{                                                                                                         \
        for (i = 0; i < dst->height; ++i)                                                                       \
            for (j = 0; j < dst->width; ++j)                                                                    \
            {                                                                                                   \
                int32_t val = src0->data.s0[i * src0->stride + j];                                              \
                val += src1->data.s1[i * src1->stride + j];                                                     \
                dst->data.r[i * dst->stride + j] = (val < min_bound ? min_bound :                               \
                                                                        (val > max_bound ? max_bound : val));   \
            }                                                                                                   \
    }while(0)

    if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_U8)
        ADD_LOOP(y, y, y);
    else if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_S16)
        ADD_LOOP(y, y, s16);
    else if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_S16 && dst->format == VX_DF_IMAGE_S16)
        ADD_LOOP(y, s16, s16);
    else if (src0->format == VX_DF_IMAGE_S16 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_S16)
        ADD_LOOP(s16, y, s16);
    else if (src0->format == VX_DF_IMAGE_S16 && src1->format == VX_DF_IMAGE_S16 && dst->format == VX_DF_IMAGE_S16)
        ADD_LOOP(s16, s16, s16);
    else
        FAIL("Unsupported combination of argument formats: %.4s + %.4s = %.4s", &src0->format, &src1->format, &dst->format);

#undef ADD_LOOP
}

static void referenceSubtract(CT_Image src0, CT_Image src1, CT_Image dst, enum vx_convert_policy_e policy)
{
    int32_t min_bound, max_bound;
    uint32_t i, j;
    ASSERT(src0 && src1 && dst);
    ASSERT(src0->width = src1->width && src0->width == dst->width);
    ASSERT(src0->height = src1->height && src0->height == dst->height);

    switch (policy)
    {
        case VX_CONVERT_POLICY_SATURATE:
            if (dst->format == VX_DF_IMAGE_U8)
            {
                min_bound = 0;
                max_bound = 255;
            }
            else if (dst->format == VX_DF_IMAGE_S16)
            {
                min_bound = -32768;
                max_bound =  32767;
            }
            else
                FAIL("Unsupported result format: (%.4s)", &dst->format);
            break;
        case VX_CONVERT_POLICY_WRAP:
            min_bound = INT32_MIN;
            max_bound = INT32_MAX;
            break;
        default: FAIL("Unknown owerflow policy"); break;
    };

#define SUB_LOOP(s0, s1, r)                                                                                     \
    do{                                                                                                         \
        for (i = 0; i < dst->height; ++i)                                                                       \
            for (j = 0; j < dst->width; ++j)                                                                    \
            {                                                                                                   \
                int32_t val = src0->data.s0[i * src0->stride + j];                                              \
                val -= src1->data.s1[i * src1->stride + j];                                                     \
                dst->data.r[i * dst->stride + j] = (val < min_bound ? min_bound :                               \
                                                                        (val > max_bound ? max_bound : val));   \
            }                                                                                                   \
    }while(0)

    if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_U8)
        SUB_LOOP(y, y, y);
    else if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_S16)
        SUB_LOOP(y, y, s16);
    else if (src0->format == VX_DF_IMAGE_U8 && src1->format == VX_DF_IMAGE_S16 && dst->format == VX_DF_IMAGE_S16)
        SUB_LOOP(y, s16, s16);
    else if (src0->format == VX_DF_IMAGE_S16 && src1->format == VX_DF_IMAGE_U8 && dst->format == VX_DF_IMAGE_S16)
        SUB_LOOP(s16, y, s16);
    else if (src0->format == VX_DF_IMAGE_S16 && src1->format == VX_DF_IMAGE_S16 && dst->format == VX_DF_IMAGE_S16)
        SUB_LOOP(s16, s16, s16);
    else
        FAIL("Unsupported combination of argument formats: %.4s + %.4s = %.4s", &src0->format, &src1->format, &dst->format);

#undef SUB_LOOP
}

typedef vx_status (VX_API_CALL *vxuArithmFunction)(vx_context, vx_image, vx_image, vx_enum, vx_image);
typedef vx_node   (VX_API_CALL *vxArithmFunction) (vx_graph, vx_image, vx_image, vx_enum, vx_image);
typedef void      (*referenceFunction)(CT_Image, CT_Image, CT_Image, enum vx_convert_policy_e);

#define SGN_Add "+"
#define SGN_Subtract "-"

typedef struct {
    const char* name;
    enum vx_convert_policy_e policy;
    vx_df_image arg1_format;
    int arg1;
    vx_df_image arg2_format;
    int arg2;
    vx_df_image result_format;
    int expected_result;
    vxuArithmFunction vxuFunc;
    vxArithmFunction vxFunc;
} overflow_arg;

#define OVERFLOW_ARG(func, p, f1, f2, fr, v1, v2, vr) \
    ARG(#func ": " #p " " #f1 "(" #v1 ") " SGN_##func " " #f2 "(" #v2 ") = " #fr "(" #vr ")", \
        VX_CONVERT_POLICY_##p, VX_DF_IMAGE_##f1, v1, VX_DF_IMAGE_##f2, v2, VX_DF_IMAGE_##fr, vr, vxu##func, vx##func##Node)\

#define ADDSUB_OVERFLOW_ARGS                                                                        \
    OVERFLOW_ARG(Add, SATURATE, U8, U8, U8, 175, 210, 255), /* with overflow */                     \
    OVERFLOW_ARG(Add, SATURATE, U8, U8, U8, 0,   255, 255), /* normal        */                     \
    OVERFLOW_ARG(Add, WRAP,     U8, U8, U8, 175, 210, 129), /* with overflow */                     \
    OVERFLOW_ARG(Add, WRAP,     U8, U8, U8, 0,   255, 255), /* normal        */                     \
                                                                                                    \
    OVERFLOW_ARG(Add, SATURATE, U8, U8, S16, 175, 210, 385), /* normal */                           \
    OVERFLOW_ARG(Add, WRAP,     U8, U8, S16, 255, 255, 510), /* normal */                           \
                                                                                                    \
    OVERFLOW_ARG(Add, SATURATE, U8, S16, S16, 175, 32760, 32767),  /* with overflow */              \
    OVERFLOW_ARG(Add, SATURATE, U8, S16, S16, 175, -1000, -825),   /* normal        */              \
    OVERFLOW_ARG(Add, WRAP,     U8, S16, S16, 1,   32767, -32768), /* with overflow */              \
    OVERFLOW_ARG(Add, WRAP,     U8, S16, S16, 255, -1000, -745),   /* normal        */              \
                                                                                                    \
    OVERFLOW_ARG(Add, SATURATE, S16, U8, S16, 32513, 255, 32767),  /* with overflow */              \
    OVERFLOW_ARG(Add, SATURATE, S16, U8, S16, 32512, 255, 32767),  /* normal        */              \
    OVERFLOW_ARG(Add, WRAP,     S16, U8, S16, 32514, 255, -32767), /* with overflow */              \
    OVERFLOW_ARG(Add, WRAP,     S16, U8, S16, 0,     0,   0),      /* normal        */              \
                                                                                                    \
    OVERFLOW_ARG(Add, SATURATE, S16, S16, S16,  32000, -32000,  0),     /* normal         */        \
    OVERFLOW_ARG(Add, SATURATE, S16, S16, S16,  32000,  32000,  32767), /* with overflow  */        \
    OVERFLOW_ARG(Add, SATURATE, S16, S16, S16, -32000, -32000, -32768), /* with underflow */        \
    OVERFLOW_ARG(Add, WRAP,     S16, S16, S16, -32768,  32767, -1),     /* normal         */        \
    OVERFLOW_ARG(Add, WRAP,     S16, S16, S16,  32767,  32767, -2),     /* with overflow  */        \
    OVERFLOW_ARG(Add, WRAP,     S16, S16, S16, -17000, -17000,  31536), /* with underflow */        \
                                                                                                    \
    OVERFLOW_ARG(Subtract, SATURATE, U8, U8, U8, 175, 210, 0),   /* with underflow */               \
    OVERFLOW_ARG(Subtract, SATURATE, U8, U8, U8, 255,  55, 200), /* normal         */               \
    OVERFLOW_ARG(Subtract, WRAP,     U8, U8, U8, 175, 210, 221), /* with underflow */               \
    OVERFLOW_ARG(Subtract, WRAP,     U8, U8, U8, 250, 240, 10),  /* normal         */               \
                                                                                                    \
    OVERFLOW_ARG(Subtract, SATURATE, U8, U8, S16, 175, 210, -35), /* normal */                      \
    OVERFLOW_ARG(Subtract, WRAP,     U8, U8, S16, 254, 255, -1),  /* normal */                      \
                                                                                                    \
    OVERFLOW_ARG(Subtract, SATURATE, U8, S16, S16, 175, -32760, 32767),  /* with overflow */        \
    OVERFLOW_ARG(Subtract, SATURATE, U8, S16, S16, 175, 1000, -825),     /* normal        */        \
    OVERFLOW_ARG(Subtract, WRAP,     U8, S16, S16, 1,   -32767, -32768), /* with overflow */        \
    OVERFLOW_ARG(Subtract, WRAP,     U8, S16, S16, 255, 1000, -745),     /* normal        */        \
                                                                                                    \
    OVERFLOW_ARG(Subtract, SATURATE, S16, U8, S16, -32514, 255, -32768), /* with underflow */       \
    OVERFLOW_ARG(Subtract, SATURATE, S16, U8, S16, -32513, 255, -32768), /* normal         */       \
    OVERFLOW_ARG(Subtract, WRAP,     S16, U8, S16, -32514, 255, 32767),  /* with underflow */       \
    OVERFLOW_ARG(Subtract, WRAP,     S16, U8, S16,  0,     0,   0),      /* normal         */       \
                                                                                                    \
    OVERFLOW_ARG(Subtract, SATURATE, S16, S16, S16,  32000,  32000,  0),     /* normal         */   \
    OVERFLOW_ARG(Subtract, SATURATE, S16, S16, S16,  32000, -32000,  32767), /* with overflow  */   \
    OVERFLOW_ARG(Subtract, SATURATE, S16, S16, S16, -32000,  32000, -32768), /* with underflow */   \
    OVERFLOW_ARG(Subtract, WRAP,     S16, S16, S16, -32768, -32767, -1),     /* normal         */   \
    OVERFLOW_ARG(Subtract, WRAP,     S16, S16, S16,  32767, -32767, -2),     /* with overflow  */   \
    OVERFLOW_ARG(Subtract, WRAP,     S16, S16, S16, -17000,  17000,  31536), /* with underflow */

typedef struct {
    const char* name;
    enum vx_convert_policy_e policy;
    int width, height;
    vx_df_image arg1_format, arg2_format, result_format;
    vxuArithmFunction vxuFunc;
    vxArithmFunction vxFunc;
    referenceFunction referenceFunc;
} fuzzy_arg, formats_arg;

#define FUZZY_ARG(func, p, w, h, f1, f2, fr)        \
    ARG(#func ": " #p " " #w "x" #h " " #f1 SGN_##func #f2 "=" #fr,   \
        VX_CONVERT_POLICY_##p, w, h, VX_DF_IMAGE_##f1, VX_DF_IMAGE_##f2, VX_DF_IMAGE_##fr, vxu##func, vx##func##Node, reference##func)

#define FORMATS_ARG(func, p, f1, f2, fr)  \
    ARG(#func ": " #p " " #f1 SGN_##func #f2 "=" #fr, \
        VX_CONVERT_POLICY_##p, 0, 0, VX_DF_IMAGE_##f1, VX_DF_IMAGE_##f2, VX_DF_IMAGE_##fr, vxu##func, vx##func##Node, reference##func)

#define ARITHM_INVALID_FORMATS(func)            \
    FORMATS_ARG(func, SATURATE, S16, S16, U8),  \
    FORMATS_ARG(func, SATURATE, S16, U8,  U8),  \
    FORMATS_ARG(func, SATURATE, U8,  S16, U8),  \
    FORMATS_ARG(func, WRAP, S16, S16, U8),      \
    FORMATS_ARG(func, WRAP, S16, U8,  U8),      \
    FORMATS_ARG(func, WRAP, U8,  S16, U8)

#define ARITHM_INFERENCE_FORMATS(func)          \
    FORMATS_ARG(func, SATURATE, S16, S16, S16), \
    FORMATS_ARG(func, SATURATE, S16, U8,  S16), \
    FORMATS_ARG(func, SATURATE, U8,  S16, S16), \
    FORMATS_ARG(func, SATURATE, U8,  U8,  S16), \
    FORMATS_ARG(func, WRAP, S16, S16, S16),     \
    FORMATS_ARG(func, WRAP, S16, U8,  S16),     \
    FORMATS_ARG(func, WRAP, U8,  S16, S16),     \
    FORMATS_ARG(func, WRAP, U8,  U8,  S16)

#define ARITHM_VALID_FORMATS(func)              \
    ARITHM_INFERENCE_FORMATS(func),             \
    FORMATS_ARG(func, SATURATE, U8, U8, U8),    \
    FORMATS_ARG(func, WRAP, U8, U8, U8)

#define ARITHM_FUZZY_ARGS(func)                         \
    FUZZY_ARG(func, SATURATE, 640, 480, U8, U8, U8),    \
    FUZZY_ARG(func, SATURATE, 640, 480, U8, U8, S16),   \
    FUZZY_ARG(func, SATURATE, 640, 480, U8, S16, S16),  \
    FUZZY_ARG(func, SATURATE, 640, 480, S16, U8, S16),  \
    FUZZY_ARG(func, SATURATE, 640, 480, S16, S16, S16), \
                                                        \
    FUZZY_ARG(func, WRAP, 640, 480, U8, U8, U8),        \
    FUZZY_ARG(func, WRAP, 640, 480, U8, U8, S16),       \
    FUZZY_ARG(func, WRAP, 640, 480, U8, S16, S16),      \
    FUZZY_ARG(func, WRAP, 640, 480, S16, U8, S16),      \
    FUZZY_ARG(func, WRAP, 640, 480, S16, S16, S16),     \
                                                        \
    ARG_EXTENDED_BEGIN(),                               \
    FUZZY_ARG(func, SATURATE, 15, 15, U8, U8, U8),      \
    FUZZY_ARG(func, SATURATE, 15, 15, U8, U8, S16),     \
    FUZZY_ARG(func, SATURATE, 15, 15, U8, S16, S16),    \
    FUZZY_ARG(func, SATURATE, 15, 15, S16, U8, S16),    \
    FUZZY_ARG(func, SATURATE, 15, 15, S16, S16, S16),   \
                                                        \
    FUZZY_ARG(func, SATURATE, 1280, 720, U8, U8, U8),   \
    FUZZY_ARG(func, SATURATE, 1280, 720, U8, U8, S16),  \
    FUZZY_ARG(func, SATURATE, 1280, 720, U8, S16, S16), \
    FUZZY_ARG(func, SATURATE, 1280, 720, S16, U8, S16), \
    FUZZY_ARG(func, SATURATE, 1280, 720, S16, S16, S16),\
                                                        \
    FUZZY_ARG(func, WRAP, 15, 15, U8, U8, U8),          \
    FUZZY_ARG(func, WRAP, 15, 15, U8, U8, S16),         \
    FUZZY_ARG(func, WRAP, 15, 15, U8, S16, S16),        \
    FUZZY_ARG(func, WRAP, 15, 15, S16, U8, S16),        \
    FUZZY_ARG(func, WRAP, 15, 15, S16, S16, S16),       \
                                                        \
    FUZZY_ARG(func, WRAP, 1280, 720, U8, U8, U8),       \
    FUZZY_ARG(func, WRAP, 1280, 720, U8, U8, S16),      \
    FUZZY_ARG(func, WRAP, 1280, 720, U8, S16, S16),     \
    FUZZY_ARG(func, WRAP, 1280, 720, S16, U8, S16),     \
    FUZZY_ARG(func, WRAP, 1280, 720, S16, S16, S16),    \
    ARG_EXTENDED_END()

TESTCASE(vxuAddSub, CT_VXContext, ct_setup_vx_context, 0)
TESTCASE(vxAddSub,  CT_VXContext, ct_setup_vx_context, 0)

TEST_WITH_ARG(vxuAddSub, testNegativeFormat, formats_arg, ARITHM_INVALID_FORMATS(Add), ARITHM_INVALID_FORMATS(Subtract))
{
    vx_image src1, src2, dst;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(src1 = vxCreateImage(context, 32, 32, arg_->arg1_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2 = vxCreateImage(context, 32, 32, arg_->arg2_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst  = vxCreateImage(context, 32, 32, arg_->result_format), VX_TYPE_IMAGE);

    // initialize to guarantee that images are allocated
    ASSERT_NO_FAILURE(ct_fill_image_random(src1, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src2, &CT()->seed_));

    // The output image can be VX_DF_IMAGE_U8 only if both source images are
    // VX_DF_IMAGE_U8 and the output image is explicitly set to VX_DF_IMAGE_U8. It is
    // otherwise VX_DF_IMAGE_S16.
    ASSERT_NE_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1, src2, arg_->policy, dst));

    VX_CALL(vxReleaseImage(&src1));
    VX_CALL(vxReleaseImage(&src2));
    VX_CALL(vxReleaseImage(&dst));
}

TEST_WITH_ARG(vxAddSub, testNegativeFormat, formats_arg, ARITHM_INVALID_FORMATS(Add), ARITHM_INVALID_FORMATS(Subtract))
{
    vx_image src1, src2, dst;
    vx_graph graph;
    vx_context context = context_->vx_context_;

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

    ASSERT_VX_OBJECT(src1 = vxCreateImage(context, 32, 32, arg_->arg1_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2 = vxCreateImage(context, 32, 32, arg_->arg2_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst  = vxCreateImage(context, 32, 32, arg_->result_format), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(arg_->vxFunc(graph, src1, src2, arg_->policy, dst), VX_TYPE_NODE);

    // The output image can be VX_DF_IMAGE_U8 only if both source images are
    // VX_DF_IMAGE_U8 and the output image is explicitly set to VX_DF_IMAGE_U8. It is
    // otherwise VX_DF_IMAGE_S16.
    ASSERT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph));

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

TEST_WITH_ARG(vxuAddSub, testNegativeSizes, formats_arg, ARITHM_VALID_FORMATS(Add), ARITHM_VALID_FORMATS(Subtract))
{
    vx_image src1_32x32, src1_64x64, src2_32x32, src2_32x64, dst32x32, dst88x16;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(src1_32x32 = vxCreateImage(context, 32, 32, arg_->arg1_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src1_64x64 = vxCreateImage(context, 64, 64, arg_->arg1_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2_32x32 = vxCreateImage(context, 32, 32, arg_->arg2_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2_32x64 = vxCreateImage(context, 32, 64, arg_->arg2_format), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(dst32x32 = vxCreateImage(context, 32, 32, arg_->result_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst88x16 = vxCreateImage(context, 88, 16, arg_->result_format), VX_TYPE_IMAGE);

    // initialize to guarantee that images are allocated
    ASSERT_NO_FAILURE(ct_fill_image_random(src1_32x32, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src1_64x64, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src2_32x32, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src2_32x64, &CT()->seed_));

    EXPECT_NE_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1_32x32, src2_32x32, arg_->policy, dst88x16));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1_32x32, src2_32x64, arg_->policy, dst32x32));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1_64x64, src2_32x32, arg_->policy, dst32x32));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1_64x64, src2_32x64, arg_->policy, dst32x32));

    VX_CALL(vxReleaseImage(&src1_32x32));
    VX_CALL(vxReleaseImage(&src2_32x32));
    VX_CALL(vxReleaseImage(&src1_64x64));
    VX_CALL(vxReleaseImage(&src2_32x64));
    VX_CALL(vxReleaseImage(&dst32x32));
    VX_CALL(vxReleaseImage(&dst88x16));
}

TEST_WITH_ARG(vxAddSub, testNegativeSizes, formats_arg, ARITHM_VALID_FORMATS(Add), ARITHM_VALID_FORMATS(Subtract))
{
    vx_image src1_32x32, src1_64x64, src2_32x32, src2_32x64, dst32x32, dst88x16;
    vx_graph graph1, graph2, graph3, graph4;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(src1_32x32 = vxCreateImage(context, 32, 32, arg_->arg1_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src1_64x64 = vxCreateImage(context, 64, 64, arg_->arg1_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2_32x32 = vxCreateImage(context, 32, 32, arg_->arg2_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2_32x64 = vxCreateImage(context, 32, 64, arg_->arg2_format), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(dst32x32 = vxCreateImage(context, 32, 32, arg_->result_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst88x16 = vxCreateImage(context, 88, 16, arg_->result_format), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(graph1 = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(arg_->vxFunc(graph1, src1_32x32, src2_32x32, arg_->policy, dst88x16), VX_TYPE_NODE);
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph1));

    ASSERT_VX_OBJECT(graph2 = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(arg_->vxFunc(graph2, src1_32x32, src2_32x64, arg_->policy, dst32x32), VX_TYPE_NODE);
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph2));

    ASSERT_VX_OBJECT(graph3 = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(arg_->vxFunc(graph3, src1_64x64, src2_32x32, arg_->policy, dst32x32), VX_TYPE_NODE);
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph3));

    ASSERT_VX_OBJECT(graph4 = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(arg_->vxFunc(graph4, src1_64x64, src2_32x64, arg_->policy, dst32x32), VX_TYPE_NODE);
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxVerifyGraph(graph4));

    VX_CALL(vxReleaseImage(&src1_32x32));
    VX_CALL(vxReleaseImage(&src2_32x32));
    VX_CALL(vxReleaseImage(&src1_64x64));
    VX_CALL(vxReleaseImage(&src2_32x64));
    VX_CALL(vxReleaseImage(&dst32x32));
    VX_CALL(vxReleaseImage(&dst88x16));
    VX_CALL(vxReleaseGraph(&graph1));
    VX_CALL(vxReleaseGraph(&graph2));
    VX_CALL(vxReleaseGraph(&graph3));
    VX_CALL(vxReleaseGraph(&graph4));
}

static vx_image inference_image;
static vx_enum  inference_image_format;
static vx_action VX_CALLBACK inference_image_test(vx_node node)
{
    vx_uint32 width  = 0;
    vx_uint32 height = 0;
    vx_df_image format = 0;

    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryImage(inference_image, VX_IMAGE_WIDTH,   &width,   sizeof(width)));
    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryImage(inference_image, VX_IMAGE_HEIGHT,  &height,  sizeof(height)));
    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxQueryImage(inference_image, VX_IMAGE_FORMAT,  &format,  sizeof(format)));

    EXPECT_EQ_INT(640, width);
    EXPECT_EQ_INT(480, height);
    EXPECT_EQ_INT(inference_image_format, format);

    return VX_ACTION_CONTINUE;
}

TEST_WITH_ARG(vxAddSub, testInference, formats_arg, ARITHM_INFERENCE_FORMATS(Add), ARITHM_INFERENCE_FORMATS(Subtract))
{
    vx_image src1, src2, dst, gr;
    vx_graph graph;
    vx_node n, tmp;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(src1  = vxCreateImage(context, 640, 480, arg_->arg1_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2  = vxCreateImage(context, 640, 480, arg_->arg2_format), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst   = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(n     = arg_->vxFunc(graph, src1, src2, arg_->policy, dst), VX_TYPE_NODE);

    // grounding
    ASSERT_VX_OBJECT(gr    = vxCreateImage(context, 640, 480, VX_DF_IMAGE_S16), VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(tmp   = vxAddNode(graph, dst, src2, VX_CONVERT_POLICY_WRAP, gr), VX_TYPE_NODE);

    // test
    inference_image = dst;
    inference_image_format = arg_->result_format;
    EXPECT_EQ_VX_STATUS(VX_SUCCESS, vxAssignNodeCallback(n, inference_image_test));
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxProcessGraph(graph));

    VX_CALL(vxReleaseNode(&n));
    VX_CALL(vxReleaseNode(&tmp));
    VX_CALL(vxReleaseImage(&src1));
    VX_CALL(vxReleaseImage(&src2));
    VX_CALL(vxReleaseImage(&dst));
    VX_CALL(vxReleaseImage(&gr));
    VX_CALL(vxReleaseGraph(&graph));
}

TEST_WITH_ARG(vxuAddSub, testOverflowModes, overflow_arg, ADDSUB_OVERFLOW_ARGS)
{
    vx_image src1, src2, dst;
    vx_pixel_value_t init_val;
    vx_context context = context_->vx_context_;

    // allocate and fill images
    ASSERT_VX_OBJECT(dst = vxCreateImage(context, 640, 480, arg_->result_format), VX_TYPE_IMAGE);

    switch (arg_->arg1_format)
    {
        case VX_DF_IMAGE_U8:  init_val.U8  = arg_->arg1; break;
        case VX_DF_IMAGE_S16: init_val.S16 = arg_->arg1; break;
        default: FAIL("Bad test argument"); break;
    };
    ASSERT_VX_OBJECT(src1 = vxCreateUniformImage(context, 640, 480, arg_->arg1_format, &init_val), VX_TYPE_IMAGE);

    switch (arg_->arg2_format)
    {
        case VX_DF_IMAGE_U8:  init_val.U8  = arg_->arg2; break;
        case VX_DF_IMAGE_S16: init_val.S16 = arg_->arg2; break;
        default: FAIL("Bad test argument"); break;
    };
    ASSERT_VX_OBJECT(src2 = vxCreateUniformImage(context, 640, 480, arg_->arg2_format, &init_val), VX_TYPE_IMAGE);

    // run function
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1, src2, arg_->policy, dst));

    // test bottom right pixel to have an expected value
    {
        vx_imagepatch_addressing_t addr = VX_IMAGEPATCH_ADDR_INIT;
        void *pdata = 0;
        void *bottom_right_pixel = 0;
        vx_rectangle_t rect = {0 ,0, 640, 480};
        vx_map_id map_id;

        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxMapImagePatch(dst, &rect, 0, &map_id, &addr, &pdata, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));

        bottom_right_pixel = vxFormatImagePatchAddress2d(pdata, addr.dim_x-1, addr.dim_y-1, &addr);
        ASSERT(bottom_right_pixel != NULL);

        switch (arg_->result_format)
        {
            case VX_DF_IMAGE_U8:  EXPECT_EQ_INT(arg_->expected_result, *(uint8_t*)bottom_right_pixel); break;
            case VX_DF_IMAGE_S16: EXPECT_EQ_INT(arg_->expected_result, *(int16_t*)bottom_right_pixel); break;
            default: ADD_FAILURE("Bad test argument"); break;
        };

        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxUnmapImagePatch(dst, map_id));
    }

    // checked release vx images
    VX_CALL(vxReleaseImage(&dst));
    VX_CALL(vxReleaseImage(&src1));
    VX_CALL(vxReleaseImage(&src2));
    EXPECT_EQ_PTR(NULL, dst);
    EXPECT_EQ_PTR(NULL, src1);
    EXPECT_EQ_PTR(NULL, src2);
}

TEST_WITH_ARG(vxAddSub, testOverflowModes, overflow_arg, ADDSUB_OVERFLOW_ARGS)
{
    vx_image src1, src2, dst;
    vx_pixel_value_t init_val;
    vx_graph graph;
    vx_context context = context_->vx_context_;

    // allocate and fill images
    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(dst   = vxCreateImage(context, 640, 480, arg_->result_format), VX_TYPE_IMAGE);

    switch (arg_->arg1_format)
    {
        case VX_DF_IMAGE_U8:  init_val.U8  = arg_->arg1; break;
        case VX_DF_IMAGE_S16: init_val.S16 = arg_->arg1; break;
        default: FAIL("Bad test argument"); break;
    };
    ASSERT_VX_OBJECT(src1 = vxCreateUniformImage(context, 640, 480, arg_->arg1_format, &init_val), VX_TYPE_IMAGE);

    switch (arg_->arg2_format)
    {
        case VX_DF_IMAGE_U8:  init_val.U8  = arg_->arg2; break;
        case VX_DF_IMAGE_S16: init_val.S16 = arg_->arg2; break;
        default: FAIL("Bad test argument"); break;
    };
    ASSERT_VX_OBJECT(src2 = vxCreateUniformImage(context, 640, 480, arg_->arg2_format, &init_val), VX_TYPE_IMAGE);

    // build one-node graph
    ASSERT_VX_OBJECT(arg_->vxFunc(graph, src1, src2, arg_->policy, dst), VX_TYPE_NODE);

    // run graph
#ifdef CT_EXECUTE_ASYNC
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxScheduleGraph(graph));
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxWaitGraph(graph));
#else
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxProcessGraph(graph));
#endif

    // test bottom right pixel to have an expected value
    {
        vx_imagepatch_addressing_t addr = VX_IMAGEPATCH_ADDR_INIT;
        void *pdata = 0;
        void *bottom_right_pixel = 0;
        vx_rectangle_t rect = {0 ,0, 640, 480};
        vx_map_id map_id;

        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxMapImagePatch(dst, &rect, 0, &map_id, &addr, &pdata, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0));

        bottom_right_pixel = vxFormatImagePatchAddress2d(pdata, addr.dim_x-1, addr.dim_y-1, &addr);
        ASSERT(bottom_right_pixel != NULL);

        switch (arg_->result_format)
        {
            case VX_DF_IMAGE_U8:  EXPECT_EQ_INT(arg_->expected_result, *(uint8_t*)bottom_right_pixel); break;
            case VX_DF_IMAGE_S16: EXPECT_EQ_INT(arg_->expected_result, *(int16_t*)bottom_right_pixel); break;
            default: ADD_FAILURE("Bad test argument"); break;
        };

        ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxUnmapImagePatch(dst, map_id));
    }

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

TEST_WITH_ARG(vxuAddSub, testFuzzy, fuzzy_arg, ARITHM_FUZZY_ARGS(Add), ARITHM_FUZZY_ARGS(Subtract))
{
    vx_image src1, src2, dst;
    CT_Image ref1, ref2, refdst, vxdst;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(src1 = vxCreateImage(context, arg_->width, arg_->height, arg_->arg1_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2 = vxCreateImage(context, arg_->width, arg_->height, arg_->arg2_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(dst  = vxCreateImage(context, arg_->width, arg_->height, arg_->result_format), VX_TYPE_IMAGE);

    ASSERT_NO_FAILURE(ct_fill_image_random(src1, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src2, &CT()->seed_));

    ASSERT_EQ_VX_STATUS(VX_SUCCESS, arg_->vxuFunc(context, src1, src2, arg_->policy, dst));

    ref1  = ct_image_from_vx_image(src1);
    ref2  = ct_image_from_vx_image(src2);
    vxdst = ct_image_from_vx_image(dst);
    refdst = ct_allocate_image(arg_->width, arg_->height, arg_->result_format);

    arg_->referenceFunc(ref1, ref2, refdst, arg_->policy);

    ASSERT_EQ_CTIMAGE(refdst, vxdst);

    // checked release vx images
    VX_CALL(vxReleaseImage(&dst));
    VX_CALL(vxReleaseImage(&src1));
    VX_CALL(vxReleaseImage(&src2));
    EXPECT_EQ_PTR(NULL, dst);
    EXPECT_EQ_PTR(NULL, src1);
    EXPECT_EQ_PTR(NULL, src2);
}

TEST_WITH_ARG(vxAddSub, testFuzzy, fuzzy_arg, ARITHM_FUZZY_ARGS(Add), ARITHM_FUZZY_ARGS(Subtract))
{
    vx_image src1, src2, dst;
    vx_graph graph;
    CT_Image ref1, ref2, refdst, vxdst;
    vx_context context = context_->vx_context_;

    ASSERT_VX_OBJECT(graph = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(dst   = vxCreateImage(context, arg_->width, arg_->height, arg_->result_format), VX_TYPE_IMAGE);

    ASSERT_VX_OBJECT(src1 = vxCreateImage(context, arg_->width, arg_->height, arg_->arg1_format),   VX_TYPE_IMAGE);
    ASSERT_VX_OBJECT(src2 = vxCreateImage(context, arg_->width, arg_->height, arg_->arg2_format),   VX_TYPE_IMAGE);

    ASSERT_NO_FAILURE(ct_fill_image_random(src1, &CT()->seed_));
    ASSERT_NO_FAILURE(ct_fill_image_random(src2, &CT()->seed_));

    // build one-node graph
    ASSERT_VX_OBJECT(arg_->vxFunc(graph, src1, src2, arg_->policy, dst), VX_TYPE_NODE);

    // run graph
#ifdef CT_EXECUTE_ASYNC
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxScheduleGraph(graph));
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxWaitGraph(graph));
#else
    ASSERT_EQ_VX_STATUS(VX_SUCCESS, vxProcessGraph(graph));
#endif

    ref1  = ct_image_from_vx_image(src1);
    ref2  = ct_image_from_vx_image(src2);
    vxdst = ct_image_from_vx_image(dst);
    refdst = ct_allocate_image(arg_->width, arg_->height, arg_->result_format);

    arg_->referenceFunc(ref1, ref2, refdst, arg_->policy);

    ASSERT_EQ_CTIMAGE(refdst, vxdst);

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

TESTCASE_TESTS(vxuAddSub, DISABLED_testNegativeFormat, DISABLED_testNegativeSizes,                testOverflowModes, testFuzzy)
TESTCASE_TESTS(vxAddSub,  DISABLED_testNegativeFormat, DISABLED_testNegativeSizes, testInference, testOverflowModes, testFuzzy)