/* 

 * 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 <math.h>

#ifdef _MSC_VER
#define ONE_255 (1.0f/255)
#else
#define ONE_255 0x1.010102p-8f
#endif
#define ONE_2_0 1.0f
#define ONE_2_1 (1.0f/(1<<1))
#define ONE_2_2 (1.0f/(1<<2))
#define ONE_2_3 (1.0f/(1<<3))
#define ONE_2_4 (1.0f/(1<<4))
#define ONE_2_5 (1.0f/(1<<5))
#define ONE_2_6 (1.0f/(1<<6))
#define ONE_2_7 (1.0f/(1<<7))
#define ONE_2_8 (1.0f/(1<<8))
#define ONE_2_9 (1.0f/(1<<9))
#define ONE_2_10 (1.0f/(1<<10))
#define ONE_2_11 (1.0f/(1<<11))
#define ONE_2_12 (1.0f/(1<<12))
#define ONE_2_13 (1.0f/(1<<13))
#define ONE_2_14 (1.0f/(1<<14))
#define ONE_2_15 (1.0f/(1<<15))

#define ONE_255_STR "(1/255)"
#define ONE_2_0_STR "(1/2^0)"
#define ONE_2_1_STR "(1/2^1)"
#define ONE_2_2_STR "(1/2^2)"
#define ONE_2_3_STR "(1/2^3)"
#define ONE_2_4_STR "(1/2^4)"
#define ONE_2_5_STR "(1/2^5)"
#define ONE_2_6_STR "(1/2^6)"
#define ONE_2_7_STR "(1/2^7)"
#define ONE_2_8_STR "(1/2^8)"
#define ONE_2_9_STR "(1/2^9)"
#define ONE_2_10_STR "(1/2^10)"
#define ONE_2_11_STR "(1/2^11)"
#define ONE_2_12_STR "(1/2^12)"
#define ONE_2_13_STR "(1/2^13)"
#define ONE_2_14_STR "(1/2^14)"
#define ONE_2_15_STR "(1/2^15)"

//#define CT_EXECUTE_ASYNC

static void referenceMultiply(CT_Image src0, CT_Image src1, CT_Image dst, CT_Image dst_plus_1, vx_float32 scale, enum vx_convert_policy_e policy)
{
    int32_t min_bound, max_bound;
    uint32_t i, j;

    ASSERT(src0 && src1 && dst && dst_plus_1);
    ASSERT(src0->width  == src1->width  && src0->width  == dst->width  && src0->width  == dst_plus_1->width);
    ASSERT(src0->height == src1->height && src0->height == dst->height && src0->height == dst_plus_1->height);
    ASSERT(dst->format == dst_plus_1->format);

    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 MULTIPLY_LOOP(s0, s1, r)                                                                                \
    do{                                                                                                         \
        for (i = 0; i < dst->height; ++i)                                                                       \
            for (j = 0; j < dst->width; ++j)                                                                    \
            {                                                                                                   \
                int32_t val0 = src0->data.s0[i * src0->stride + j];                                             \
                int32_t val1 = src1->data.s1[i * src1->stride + j];                                             \
                /* use double precision because in S16*S16 case (val0*val1) can be not representable as float */\
                int32_t res0 = (int32_t)floor(((double)(val0 * val1)) * scale);                                 \
                int32_t res1 = res0 + 1;                                                                        \
                dst->data.r[i * dst->stride + j] = (res0 < min_bound ? min_bound :                              \
                                                                        (res0 > max_bound ? max_bound : res0)); \
                dst_plus_1->data.r[i * dst_plus_1->stride + j] = (res1 < min_bound ? min_bound :                \
                                                                        (res1 > max_bound ? max_bound : res1)); \
            }                                                                                                   \
    }while(0)

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

#undef MULTIPLY_LOOP
}

typedef struct {
    const char* name;
    enum vx_convert_policy_e overflow_policy;
    int width, height;
    vx_df_image arg1_format, arg2_format, result_format;
    enum vx_round_policy_e round_policy;
    vx_float32 scale;
} formats_arg, fuzzy_arg;

#define FORMATS_ARG(owp, f1, f2, fr, rp, scale)                 \
    ARG(#owp "/" #rp " " #f1 "*" #f2 "*" scale##_STR "=" #fr,   \
        VX_CONVERT_POLICY_##owp, 0, 0, VX_DF_IMAGE_##f1, VX_DF_IMAGE_##f2, VX_DF_IMAGE_##fr, VX_ROUND_POLICY_##rp, scale)

#define FUZZY_ARG(owp, w, h, f1, f2, fr, rp, scale)                         \
    ARG(#owp "/" #rp " " #w "x" #h " " #f1 "*" #f2 "*" scale##_STR "=" #fr, \
        VX_CONVERT_POLICY_##owp, w, h, VX_DF_IMAGE_##f1, VX_DF_IMAGE_##f2, VX_DF_IMAGE_##fr, VX_ROUND_POLICY_##rp, scale)

#define APPEND_SCALE(macro, ...)                                \
    CT_EXPAND(macro(__VA_ARGS__, TO_NEAREST_EVEN, ONE_255)),    \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_0)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_1)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_2)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_3)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_4)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_5)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_6)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_7)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_8)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_9)),            \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_10)),           \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_11)),           \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_12)),           \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_13)),           \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_14)),           \
    CT_EXPAND(macro(__VA_ARGS__, TO_ZERO, ONE_2_15))

#define MUL_INVALID_FORMATS(owp)                    \
    APPEND_SCALE(FORMATS_ARG, owp, S16, S16, U8),   \
    APPEND_SCALE(FORMATS_ARG, owp, S16, U8,  U8),   \
    APPEND_SCALE(FORMATS_ARG, owp, U8,  S16, U8)

#define MUL_INFERENCE_FORMATS(opw)                  \
    APPEND_SCALE(FORMATS_ARG, opw, S16, S16, S16),  \
    APPEND_SCALE(FORMATS_ARG, opw, S16, U8,  S16),  \
    APPEND_SCALE(FORMATS_ARG, opw, U8,  S16, S16),  \
    APPEND_SCALE(FORMATS_ARG, opw, U8,  U8,  S16)

#define MUL_VALID_FORMATS(opw) MUL_INFERENCE_FORMATS(opw), APPEND_SCALE(FORMATS_ARG, opw, U8, U8, U8)

#define MUL_FUZZY_ARGS(owp)                                 \
    APPEND_SCALE(FUZZY_ARG, owp, 640, 480, U8, U8, U8),     \
    APPEND_SCALE(FUZZY_ARG, owp, 640, 480, U8, U8, S16),    \
    APPEND_SCALE(FUZZY_ARG, owp, 640, 480, U8, S16, S16),   \
    APPEND_SCALE(FUZZY_ARG, owp, 640, 480, S16, U8, S16),   \
    APPEND_SCALE(FUZZY_ARG, owp, 640, 480, S16, S16, S16),  \
                                                            \
    ARG_EXTENDED_BEGIN(),                                   \
    APPEND_SCALE(FUZZY_ARG, owp, 15, 15, U8, U8, U8),       \
    APPEND_SCALE(FUZZY_ARG, owp, 15, 15, U8, U8, S16),      \
    APPEND_SCALE(FUZZY_ARG, owp, 15, 15, U8, S16, S16),     \
    APPEND_SCALE(FUZZY_ARG, owp, 15, 15, S16, U8, S16),     \
    APPEND_SCALE(FUZZY_ARG, owp, 15, 15, S16, S16, S16),    \
                                                            \
    APPEND_SCALE(FUZZY_ARG, owp, 1280, 720, U8, U8, U8),    \
    APPEND_SCALE(FUZZY_ARG, owp, 1280, 720, U8, U8, S16),   \
    APPEND_SCALE(FUZZY_ARG, owp, 1280, 720, U8, S16, S16),  \
    APPEND_SCALE(FUZZY_ARG, owp, 1280, 720, S16, U8, S16),  \
    APPEND_SCALE(FUZZY_ARG, owp, 1280, 720, S16, S16, S16), \
    ARG_EXTENDED_END()

TESTCASE(vxuMultiply, CT_VXContext, ct_setup_vx_context, 0)
TESTCASE(vxMultiply,  CT_VXContext, ct_setup_vx_context, 0)

TEST_WITH_ARG(vxuMultiply, testNegativeFormat, formats_arg, MUL_INVALID_FORMATS(SATURATE), MUL_INVALID_FORMATS(WRAP))
{
    vx_image src1, src2, dst;
    vx_float32 scale_val = arg_->scale;
    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, vxuMultiply(context, src1, src2, scale_val, arg_->overflow_policy, arg_->round_policy, dst));

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

TEST_WITH_ARG(vxMultiply, testNegativeFormat, formats_arg, MUL_INVALID_FORMATS(SATURATE), MUL_INVALID_FORMATS(WRAP))
{
    vx_image src1, src2, dst;
    vx_graph graph;
    vx_scalar scale;
    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(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &arg_->scale),   VX_TYPE_SCALAR);

    ASSERT_VX_OBJECT(vxMultiplyNode(graph, src1, src2, scale, arg_->overflow_policy, arg_->round_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(vxReleaseScalar(&scale));
    VX_CALL(vxReleaseGraph(&graph));
}

TEST_WITH_ARG(vxuMultiply, testNegativeSizes, formats_arg, MUL_VALID_FORMATS(SATURATE), MUL_VALID_FORMATS(WRAP))
{
    vx_image src1_32x32, src1_64x64, src2_32x32, src2_32x64, dst32x32, dst88x16;
    vx_float32 scale_val = arg_->scale;
    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, vxuMultiply(context, src1_32x32, src2_32x32, scale_val, arg_->overflow_policy, arg_->round_policy, dst88x16));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxuMultiply(context, src1_32x32, src2_32x64, scale_val, arg_->overflow_policy, arg_->round_policy, dst32x32));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxuMultiply(context, src1_64x64, src2_32x32, scale_val, arg_->overflow_policy, arg_->round_policy, dst32x32));
    EXPECT_NE_VX_STATUS(VX_SUCCESS, vxuMultiply(context, src1_64x64, src2_32x64, scale_val, arg_->overflow_policy, arg_->round_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(vxMultiply, testNegativeSizes, formats_arg, MUL_VALID_FORMATS(SATURATE), MUL_VALID_FORMATS(WRAP))
{
    vx_image src1_32x32, src1_64x64, src2_32x32, src2_32x64, dst32x32, dst88x16;
    vx_graph graph1, graph2, graph3, graph4;
    vx_scalar scale;
    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(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &arg_->scale), VX_TYPE_SCALAR);

    ASSERT_VX_OBJECT(graph1 = vxCreateGraph(context), VX_TYPE_GRAPH);
    ASSERT_VX_OBJECT(vxMultiplyNode(graph1, src1_32x32, src2_32x32, scale, arg_->overflow_policy, arg_->round_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(vxMultiplyNode(graph2, src1_32x32, src2_32x64, scale, arg_->overflow_policy, arg_->round_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(vxMultiplyNode(graph3, src1_64x64, src2_32x32, scale, arg_->overflow_policy, arg_->round_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(vxMultiplyNode(graph4, src1_64x64, src2_32x64, scale, arg_->overflow_policy, arg_->round_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(vxReleaseScalar(&scale));
    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(vxMultiply, testInference, formats_arg, MUL_INFERENCE_FORMATS(SATURATE), MUL_INFERENCE_FORMATS(WRAP))
{
    vx_image src1, src2, dst, gr;
    vx_graph graph;
    vx_scalar scale;
    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(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &arg_->scale), VX_TYPE_SCALAR);
    ASSERT_VX_OBJECT(n     = vxMultiplyNode(graph, src1, src2, scale, arg_->overflow_policy, arg_->round_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(vxReleaseScalar(&scale));
    VX_CALL(vxReleaseGraph(&graph));
}

TEST_WITH_ARG(vxuMultiply, testFuzzy, fuzzy_arg, MUL_FUZZY_ARGS(SATURATE), MUL_FUZZY_ARGS(WRAP))
{
    vx_image src1, src2, dst;
    vx_float32 scale_val = arg_->scale;
    CT_Image ref1, ref2, refdst, refdst_plus_1, 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, vxuMultiply(context, src1, src2, scale_val, arg_->overflow_policy, arg_->round_policy, dst));

    ASSERT_NO_FAILURE({
        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);
        refdst_plus_1 = ct_allocate_image(arg_->width, arg_->height, arg_->result_format);

        referenceMultiply(ref1, ref2, refdst, refdst_plus_1, arg_->scale, arg_->overflow_policy);
    });

    if (arg_->scale == ONE_2_0)
        ASSERT_EQ_CTIMAGE(refdst, vxdst);
    else
    {
        // (|ref-v| <= 1 && |ref+1-v| <= 1)  is equivalent to (v == ref || v == ref + 1)
        if (arg_->overflow_policy == VX_CONVERT_POLICY_WRAP)
        {
            EXPECT_CTIMAGE_NEARWRAP(refdst, vxdst, 1, CTIMAGE_ALLOW_WRAP);
            EXPECT_CTIMAGE_NEARWRAP(refdst_plus_1, vxdst, 1, CTIMAGE_ALLOW_WRAP);
        }
        else
        {
            EXPECT_CTIMAGE_NEAR(refdst, vxdst, 1);
            EXPECT_CTIMAGE_NEAR(refdst_plus_1, vxdst, 1);
        }
    }

    // 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(vxMultiply, testFuzzy, fuzzy_arg, MUL_FUZZY_ARGS(SATURATE), MUL_FUZZY_ARGS(WRAP))
{
    vx_image src1, src2, dst;
    vx_graph graph;
    vx_scalar scale = 0;
    CT_Image ref1, ref2, refdst, refdst_plus_1, 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(scale = vxCreateScalar(context, VX_TYPE_FLOAT32, &arg_->scale), VX_TYPE_SCALAR);

    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(vxMultiplyNode(graph, src1, src2, scale, arg_->overflow_policy, arg_->round_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

    ASSERT_NO_FAILURE({
        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);
        refdst_plus_1 = ct_allocate_image(arg_->width, arg_->height, arg_->result_format);

        referenceMultiply(ref1, ref2, refdst, refdst_plus_1, arg_->scale, arg_->overflow_policy);
    });

    if (arg_->scale == ONE_2_0)
        ASSERT_EQ_CTIMAGE(refdst, vxdst);
    else
    {
        // (|ref-v| <= 1 && |ref+1-v| <= 1)  is equivalent to (v == ref || v == ref + 1)
        if (arg_->overflow_policy == VX_CONVERT_POLICY_WRAP)
        {
            EXPECT_CTIMAGE_NEARWRAP(refdst, vxdst, 1, CTIMAGE_ALLOW_WRAP);
            EXPECT_CTIMAGE_NEARWRAP(refdst_plus_1, vxdst, 1, CTIMAGE_ALLOW_WRAP);
        }
        else
        {
            EXPECT_CTIMAGE_NEAR(refdst, vxdst, 1);
            EXPECT_CTIMAGE_NEAR(refdst_plus_1, vxdst, 1);
        }
    }

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

TESTCASE_TESTS(vxuMultiply, DISABLED_testNegativeFormat, DISABLED_testNegativeSizes,                testFuzzy)
TESTCASE_TESTS(vxMultiply,  DISABLED_testNegativeFormat, DISABLED_testNegativeSizes, testInference, testFuzzy)