/* 

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

#ifndef __VX_CT_TEST_H__
#define __VX_CT_TEST_H__

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// calc number of arguments - from 1 to 32
#define CT_EXPAND(x) x
#define CT_EXPANDN(...) __VA_ARGS__
#define CT_VAARG_NUMS(_32, _31, _30, _29, _28, _27, _26, _25, _24, _23, _22, _21, _20, _19, _18, _17, _16, _15, _14, _13, _12, _11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0, ...) _0
#define CT_VAARG_NUM(...) CT_EXPAND(CT_VAARG_NUMS(__VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))

// apply macro for every argument
#define CT_FOREACH0(OP, ...) CT_EXPAND(OP(__VA_ARGS__))
#define CT_FOREACH1(OP, op_args, x) CT_FOREACH0(OP, x, CT_EXPANDN op_args (x))
#define CT_FOREACH2(OP, op_args, x, y) CT_FOREACH0(OP, x, CT_EXPANDN op_args (x)), CT_FOREACH0(OP, y, CT_EXPANDN op_args (y))
#define CT_FOREACH3(OP, op_args, x, y, z) CT_FOREACH0(OP, x, CT_EXPANDN op_args (x)), CT_FOREACH0(OP, y, CT_EXPANDN op_args (y)), CT_FOREACH0(OP, z, CT_EXPANDN op_args (z))
#define CT_FOREACH4(OP, op_args, x, y, z, p) CT_FOREACH0(OP, x, CT_EXPANDN op_args (x)), CT_FOREACH0(OP, y, CT_EXPANDN op_args (y)), CT_FOREACH0(OP, z, CT_EXPANDN op_args (z)), CT_FOREACH0(OP, p, CT_EXPANDN op_args (p))
#define CT_FOREACH5(OP, op_args, x, y, ...)        CT_FOREACH2(OP,op_args,x,y),     CT_EXPAND(CT_FOREACH3(OP,op_args,__VA_ARGS__))
#define CT_FOREACH6(OP, op_args, x, y, z, ...)     CT_FOREACH3(OP,op_args,x,y,z),   CT_EXPAND(CT_FOREACH3(OP,op_args,__VA_ARGS__))
#define CT_FOREACH7(OP, op_args, x, y, z, p, ...)  CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH3(OP,op_args,__VA_ARGS__))
#define CT_FOREACH8(OP, op_args, x, y, z, p, ...)  CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH4(OP,op_args,__VA_ARGS__))
#define CT_FOREACH9(OP, op_args, x, y, z, p, ...)  CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH5(OP,op_args,__VA_ARGS__))
#define CT_FOREACH10(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH6(OP,op_args,__VA_ARGS__))
#define CT_FOREACH11(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH7(OP,op_args,__VA_ARGS__))
#define CT_FOREACH12(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH8(OP,op_args,__VA_ARGS__))
#define CT_FOREACH13(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH9(OP,op_args,__VA_ARGS__))
#define CT_FOREACH14(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH10(OP,op_args,__VA_ARGS__))
#define CT_FOREACH15(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH11(OP,op_args,__VA_ARGS__))
#define CT_FOREACH16(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH12(OP,op_args,__VA_ARGS__))
#define CT_FOREACH17(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH13(OP,op_args,__VA_ARGS__))
#define CT_FOREACH18(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH14(OP,op_args,__VA_ARGS__))
#define CT_FOREACH19(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH15(OP,op_args,__VA_ARGS__))
#define CT_FOREACH20(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH16(OP,op_args,__VA_ARGS__))
#define CT_FOREACH21(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH17(OP,op_args,__VA_ARGS__))
#define CT_FOREACH22(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH18(OP,op_args,__VA_ARGS__))
#define CT_FOREACH23(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH19(OP,op_args,__VA_ARGS__))
#define CT_FOREACH24(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH20(OP,op_args,__VA_ARGS__))
#define CT_FOREACH25(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH21(OP,op_args,__VA_ARGS__))
#define CT_FOREACH26(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH22(OP,op_args,__VA_ARGS__))
#define CT_FOREACH27(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH23(OP,op_args,__VA_ARGS__))
#define CT_FOREACH28(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH24(OP,op_args,__VA_ARGS__))
#define CT_FOREACH29(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH25(OP,op_args,__VA_ARGS__))
#define CT_FOREACH30(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH26(OP,op_args,__VA_ARGS__))
#define CT_FOREACH31(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH27(OP,op_args,__VA_ARGS__))
#define CT_FOREACH32(OP, op_args, x, y, z, p, ...) CT_FOREACH4(OP,op_args,x,y,z,p), CT_EXPAND(CT_FOREACH28(OP,op_args,__VA_ARGS__))
#define CT_FOREACH_HELPER2(OP, op_args, qty, ...) CT_EXPAND(CT_FOREACH##qty(OP, op_args, __VA_ARGS__))
#define CT_FOREACH_HELPER(OP, op_args, qty, ...)  CT_FOREACH_HELPER2(OP, op_args, qty, __VA_ARGS__)

/*
    CT_FOREACH - appy macro with single arguments to every element in a list
    Example:
#define SQR(x, ...) ((x)*(x))
int squares[] = {CT_FOREACH(SQR, 0, 1, 2, 3, 4, 5)};
*/
#define CT_FOREACH(OP, ...) CT_FOREACH_HELPER(OP, , CT_VAARG_NUM(__VA_ARGS__), __VA_ARGS__)
/*
    CT_FOREACHN - appy macro with multiple arguments to every element in a list
    Example (comma after 10 is required):
#define MULBYN(x, n, ...) ((n)*(x))
int squares[] = {CT_FOREACHN(MULBYN, (10,), 0, 1, 2, 3, 4, 5)};
*/
#define CT_FOREACHN(OP, op_args_with_comma, ...) CT_FOREACH_HELPER(OP, op_args_with_comma, CT_VAARG_NUM(__VA_ARGS__), __VA_ARGS__)

#ifndef NULL
#define NULL ((void*)0)
#endif
#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif
#define M_PIF   (vx_float32)M_PI

#include "test_utils.h"
#include "test_image.h"

typedef struct CT_TestCaseEntry* (*CT_RegisterTestCaseFN)();

typedef struct CT_TestEntry* (*CT_TestRegisterFN)();
typedef void (*CT_TestFn)(void* context_, void* arg_);

struct CT_TestEntry {
    struct CT_TestEntry*     next_;
    struct CT_TestCaseEntry* testcase_;
    CT_TestFn                test_fn_;
    const char*              name_;
    void*                    args_;
    int                      args_count_;
    int                      arg_size_;
};

typedef void* (*CT_SetupTestCaseFN)(); // create context
typedef void (*CT_TeardownTestCaseFN)(void* context); // release context

struct CT_TestCaseEntry {
    struct CT_TestCaseEntry* next_;
    const char*              name_;
    CT_TestRegisterFN*       test_register_fns_;
    struct CT_TestEntry*     tests_;
    CT_SetupTestCaseFN       setupFn_;
    CT_TeardownTestCaseFN    teardownFn_;
    int                      test_count_;
};

#define CT_ARRAY_DIM(array) (sizeof(array)/sizeof((array)[0]))

#define CT_MAKE_TEST_FN(fn, testcase, ...) testcase##__##fn

#define CT_TESTCASE(testcase, TypeTestCaseContext, setupTestCaseFn, teardownTestCaseFn)         \
    typedef TypeTestCaseContext Context_##testcase;                                             \
    CT_TestRegisterFN testcase##_Tests[];                                                       \
    struct CT_TestCaseEntry testcase##_TestCase = {                                             \
            NULL, #testcase, testcase##_Tests, NULL, setupTestCaseFn, teardownTestCaseFn, 0};   \
    struct CT_TestCaseEntry* testcase##_register() { return &testcase##_TestCase; }

#define CT_TEST(testcase, fn)                                                                   \
        static void testcase##_##fn##_body(Context_##testcase*, void*);                         \
        struct CT_TestEntry testcase##_##fn##_entry = {                                         \
                NULL, NULL, (CT_TestFn)testcase##_##fn##_body, #fn, NULL, 0, 0 };               \
        struct CT_TestEntry testcase##_##fn##_entry_disabled = {                                \
                NULL, NULL, (CT_TestFn)testcase##_##fn##_body, "DISABLED_" #fn, NULL, 0, 0 };   \
        static struct CT_TestEntry* CT_MAKE_TEST_FN(fn, testcase)()                             \
            { return &testcase##_##fn##_entry; }                                                \
        static struct CT_TestEntry* CT_MAKE_TEST_FN(DISABLED_##fn, testcase)()                  \
            { return &testcase##_##fn##_entry_disabled; }                                       \
        void testcase##_##fn##_body(Context_##testcase* context_, void* nullarg_)

#define CT_TEST_WITH_ARG(testcase, fn, ArgType, ...)                                            \
        static void testcase##_##fn##_body(Context_##testcase*, ArgType*);                      \
        static ArgType testcase##_##fn##_args[] = { __VA_ARGS__ };                              \
        static struct CT_TestEntry testcase##_##fn##_entry = {                                  \
                NULL, NULL, (CT_TestFn)testcase##_##fn##_body, #fn,                             \
                testcase##_##fn##_args,                                                         \
                CT_ARRAY_DIM(testcase##_##fn##_args), sizeof(testcase##_##fn##_args[0])         \
            };                                                                                  \
        static struct CT_TestEntry* CT_MAKE_TEST_FN(fn, testcase)()                             \
            { return &testcase##_##fn##_entry; }                                                \
        static struct CT_TestEntry testcase##_##fn##_entry_disabled = {                         \
                NULL, NULL, (CT_TestFn)testcase##_##fn##_body, "DISABLED_" #fn,                 \
                testcase##_##fn##_args,                                                         \
                CT_ARRAY_DIM(testcase##_##fn##_args), sizeof(testcase##_##fn##_args[0])         \
            };                                                                                  \
        static struct CT_TestEntry* CT_MAKE_TEST_FN(DISABLED_##fn, testcase)()                  \
            { return &testcase##_##fn##_entry_disabled; }                                       \
        void testcase##_##fn##_body(Context_##testcase* context_, ArgType* arg_)

#define CT_TESTCASE_TESTS(testcase, ...) CT_TestRegisterFN testcase##_Tests[] = { CT_FOREACHN(CT_MAKE_TEST_FN, (testcase,), __VA_ARGS__), NULL };

#define CT_ARG(...) { __VA_ARGS__ }
#define ARG_ENUM(val) ARG(#val, val)
#define DISABLED_ARG_ENUM(val) ARG("DISABLED_" #val, val)

extern char CT_EXTENDED_ARG_BEGIN[];
extern char CT_EXTENDED_ARG_END[];

#define ARG_EXTENDED_BEGIN() CT_ARG(CT_EXTENDED_ARG_BEGIN,)
#define ARG_EXTENDED_END() CT_ARG(CT_EXTENDED_ARG_END,)

typedef struct CT_VoidContext_ {
    int dummy; // nothing, just make MSVC happy
} CT_VoidContext;

struct CT_GlobalContextBlackBox;
struct CT_GlobalContext
{
    const char*     testname_;
    uint64_t        seed_;
    const void*     arg_;
    void*           user_context_;
    struct CT_GlobalContextBlackBox* internal_;
};

struct CT_GlobalContext* CT();

void CT_RecordFailure();
void CT_RecordFailureAt(const char* message, const char* func, const char* file, const int line);
void CT_RecordFailureAtFormat(const char* message, const char* func, const char* file, const int line, ...);
int  CT_HasFailure();

void CT_DumpMessage(const char* message, ...);

typedef void (*CT_ObjectDestructor)(void **);
typedef enum CT_GCType { CT_GC_ALL=0, CT_GC_OBJECT=1, CT_GC_IMAGE=2 } CT_GCType;
void CT_RegisterForGarbageCollection(void *object, CT_ObjectDestructor collector, CT_GCType type);
void CT_CollectGarbage(int type);

#define CT_DO_FAIL /* TODO fail */ return
#define CT_PASS() return

// TODO: possibly use the trick instead of non-standard ##__VA_ARGS__
// http://stackoverflow.com/questions/5588855/standard-alternative-to-gccs-va-args-trick/11172679#11172679
#define CT_FAIL_(ret_error, message, ...)                                                   \
    do {                                                                                    \
        CT_RecordFailureAtFormat(message, __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); \
        ret_error;                                                                          \
    } while(0)

#define CT_FAIL_AT_(ret_error, message, func, file, line, ...)                              \
    do {                                                                                    \
        CT_RecordFailureAtFormat(message, func, file, line, ##__VA_ARGS__);                 \
        {ret_error;}                                                                        \
    } while(0)

#define CT_ASSERT_IMPL(ret_error, expr, exprStr, func, file, line)  \
    do { if (!!(expr)) { } else { CT_FAIL_AT_(ret_error, "Assertion: %s", func, file, line, exprStr); } } while (0)

#define CT_ADD_FAILURE(message, ...) CT_FAIL_(, message, ##__VA_ARGS__)
#define CT_FAIL(message, ...) CT_FAIL_(CT_DO_FAIL, message, ##__VA_ARGS__)
#define CT_FAIL_AT(message, func, file, line, ...) CT_FAIL_AT_(CT_DO_FAIL, message, func, file, line, ##__VA_ARGS__)

#define CT_ASSERT_AT(expr, func, file, line)  CT_ASSERT_IMPL(CT_DO_FAIL, expr, #expr, func, file, line)
#define CT_EXPECT_AT(expr, func, file, line)  CT_ASSERT_IMPL({}, expr, #expr, func, file, line)
#define CT_ASSERT_AT_(ret_error, expr, func, file, line) CT_ASSERT_IMPL(ret_error, expr, #expr, func, file, line)

#define CT_ASSERT(expr) CT_ASSERT_IMPL(CT_DO_FAIL, expr, #expr, __FUNCTION__, __FILE__, __LINE__)
#define CT_EXPECT(expr) CT_ASSERT_IMPL({}, expr, #expr, __FUNCTION__, __FILE__, __LINE__)
#define CT_ASSERT_(ret_error, expr) CT_ASSERT_IMPL(ret_error, expr, #expr, __FUNCTION__, __FILE__, __LINE__)

#define CT_ASSERT_NO_FAILURE_IMPL(ret_error, statement, message) \
    do { \
        int ct_failures_before__ = CT_HasFailure(); \
        {statement;} \
        if (ct_failures_before__ < CT_HasFailure()) \
        { \
            CT_DumpMessage("FAILED during execution of statement:\n\t%20s:%d:\n\t\t%s", __FILE__, __LINE__, message); \
            {ret_error;} \
        } \
    } while(0)
#define CT_ASSERT_NO_FAILURE(statement) CT_ASSERT_NO_FAILURE_IMPL(CT_DO_FAIL, statement, #statement)
#define CT_ASSERT_NO_FAILURE_(ret_error, statement) CT_ASSERT_NO_FAILURE_IMPL(ret_error, statement, #statement)

#define ASSERT_EQ_INT(expected, actual)                                 \
    do {                                                                \
        intmax_t s0 = (intmax_t)(expected);                             \
        intmax_t s1 = (intmax_t)(actual);                               \
        if (s0 == s1) {/*passed*/} else                                 \
        {                                                               \
            CT_RecordFailureAtFormat("Expected: %s == %s\n\t"           \
                "Actual: %lld != %lld"                                  \
                , __FUNCTION__, __FILE__, __LINE__,                     \
                #expected, #actual, (long long)s0, (long long)s1);      \
            {CT_DO_FAIL;}                                               \
        }                                                               \
    }while(0)

#define EXPECT_EQ_INT(expected, actual)                                 \
    do {                                                                \
        intmax_t s0 = (intmax_t)(expected);                             \
        intmax_t s1 = (intmax_t)(actual);                               \
        if (s0 == s1) {/*passed*/} else                                 \
        {                                                               \
            CT_RecordFailureAtFormat("Expected: %s == %s\n\t"           \
                "Actual: %lld != %lld"                                  \
                , __FUNCTION__, __FILE__, __LINE__,                     \
                #expected, #actual, (long long)s0, (long long)s1);      \
        }                                                               \
    }while(0)

#define ASSERT_EQ_PTR(expected, actual)                                 \
    do {                                                                \
        void* s0 = (void*)(expected);                                   \
        void* s1 = (void*)(actual);                                     \
        if (s0 == s1) {/*passed*/} else                                 \
        {                                                               \
            CT_RecordFailureAtFormat("Expected: %s == %s\n\t"           \
                "Actual: %p != %p"                                      \
                , __FUNCTION__, __FILE__, __LINE__,                     \
                #expected, #actual, s0, s1);                            \
            {CT_DO_FAIL;}                                               \
        }                                                               \
    }while(0)

#define EXPECT_EQ_PTR(expected, actual)                                 \
    do {                                                                \
        void* s0 = (void*)(expected);                                   \
        void* s1 = (void*)(actual);                                     \
        if (s0 == s1) {/*passed*/} else                                 \
        {                                                               \
            CT_RecordFailureAtFormat("Expected: %s == %s\n\t"           \
                "Actual: %p != %p"                                      \
                , __FUNCTION__, __FILE__, __LINE__,                     \
                #expected, #actual, s0, s1);                            \
        }                                                               \
    }while(0)

#define CT_GENERATE_PARAMETERS(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName, __VA_ARGS__))

#define ARG_PUT_0(testArgName, nextmacro, ...) CT_EXPAND(nextmacro(testArgName "/0", __VA_ARGS__, 0))
#define ARG_PUT_1(testArgName, nextmacro, ...) CT_EXPAND(nextmacro(testArgName "/1", __VA_ARGS__, 1))
#define ARG_PUT_2(testArgName, nextmacro, ...) CT_EXPAND(nextmacro(testArgName "/2", __VA_ARGS__, 2))
#define ARG_PUT_3(testArgName, nextmacro, ...) CT_EXPAND(nextmacro(testArgName "/3", __VA_ARGS__, 3))
#define ARG_PUT_4(testArgName, nextmacro, ...) CT_EXPAND(nextmacro(testArgName "/4", __VA_ARGS__, 4))

#define ADD_SIZE_NONE(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName, __VA_ARGS__, 0, 0))

#define ADD_SIZE_SMALL_SET(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sz=16x16", __VA_ARGS__, 16, 16)), \
    CT_EXPAND(nextmacro(testArgName "/sz=256x256", __VA_ARGS__, 256, 256)), \
    CT_EXPAND(nextmacro(testArgName "/sz=640x480", __VA_ARGS__, 640, 480))

#define ADD_SIZE_16x16(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sz=16x16", __VA_ARGS__, 16, 16))

#define ADD_SIZE_64x64(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sz=64x64", __VA_ARGS__, 64, 64))

#define ADD_SIZE_256x256(testArgName, nextmacro, ...) \
    CT_EXPAND(nextmacro(testArgName "/sz=256x256", __VA_ARGS__, 256, 256))

#ifndef CT_DONT_DEFINE_PUBLIC_MACROS

#define TESTCASE CT_TESTCASE
#define TEST     CT_TEST
#define ARG      CT_ARG
#define TEST_WITH_ARG  CT_TEST_WITH_ARG
#define TESTCASE_TESTS CT_TESTCASE_TESTS

#define PASS CT_PASS

#define FAIL  CT_FAIL
#define FAIL_ CT_FAIL_

#define FAIL_AT  CT_FAIL_AT
#define FAIL_AT_ CT_FAIL_AT_

#define ADD_FAILURE CT_ADD_FAILURE
#define ASSERT_NO_FAILURE CT_ASSERT_NO_FAILURE
#define ASSERT_NO_FAILURE_ CT_ASSERT_NO_FAILURE_

#define ASSERT  CT_ASSERT
#define EXPECT  CT_EXPECT
#define ASSERT_ CT_ASSERT_

#define ASSERT_AT  CT_ASSERT_AT
#define EXPECT_AT  CT_EXPECT_AT
#define ASSERT_AT_ CT_ASSERT_AT_

#define CT_Immediate_MODE 0
#define CT_Graph_MODE 1


#if defined(_MSC_VER)
#define CT_INLINE _inline
#define snprintf(buf, sz, pattern, ...) _snprintf_s(buf, sz, _TRUNCATE, pattern, __VA_ARGS__)
#else
#define CT_INLINE inline
#endif

#endif

#endif // __VX_CT_TEST_H__