/*
	AUTOMATICALLY GENERATED FILE - DO NOT EDIT!
	Please change MatrixNxN.py and re-run it
*/
/* Generated with ./VectorN.py n = 4, TYPE = int */

#include "ZUnitTest.hpp"
#include <float.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <SST/SST_Vec4.h>




static const char* testSST_Math_Vec4iAdd();
static const char* testSST_Math_Vec4iAddLocal();
static const char* testSST_Math_Vec4iSubtract();
static const char* testSST_Math_Vec4iSubtractLocal();
static const char* testSST_Math_Vec4iMultiply();
static const char* testSST_Math_Vec4iMultiplyLocal();
static const char* testSST_Math_Vec4iScale();
static const char* testSST_Math_Vec4iScaleLocal();
static const char* testSST_Math_Vec4iDivide();
static const char* testSST_Math_Vec4iDivideLocal();
static const char* testSST_Math_Vec4iAbs();
static const char* testSST_Math_Vec4iAbsLocal();
static const char* testSST_Math_Vec4iNegate();
static const char* testSST_Math_Vec4iNegateLocal();
static const char* testSST_Math_Vec4iBias();
static const char* testSST_Math_Vec4iBiasLocal();
static const char* testSST_Math_Vec4iMagnitudeSquared();
static const char* testSST_Math_Vec4iDot();
// List of unit tests 
ZUnitTest SST_Math_Vec4iUnitTests[] = 
{
{ "testSST_Math_Vec4iAdd                        " , testSST_Math_Vec4iAdd                         },
{ "testSST_Math_Vec4iAddLocal                   " , testSST_Math_Vec4iAddLocal                    },
{ "testSST_Math_Vec4iSubtract                   " , testSST_Math_Vec4iSubtract                    },
{ "testSST_Math_Vec4iSubtractLocal              " , testSST_Math_Vec4iSubtractLocal               },
{ "testSST_Math_Vec4iMultiply                   " , testSST_Math_Vec4iMultiply                    },
{ "testSST_Math_Vec4iMultiplyLocal              " , testSST_Math_Vec4iMultiplyLocal               },
{ "testSST_Math_Vec4iScale                      " , testSST_Math_Vec4iScale                       },
{ "testSST_Math_Vec4iScaleLocal                 " , testSST_Math_Vec4iScaleLocal                  },
{ "testSST_Math_Vec4iDivide                     " , testSST_Math_Vec4iDivide                      },
{ "testSST_Math_Vec4iDivideLocal                " , testSST_Math_Vec4iDivideLocal                 },
{ "testSST_Math_Vec4iAbs                        " , testSST_Math_Vec4iAbs                         },
{ "testSST_Math_Vec4iAbsLocal                   " , testSST_Math_Vec4iAbsLocal                    },
{ "testSST_Math_Vec4iNegate                     " , testSST_Math_Vec4iNegate                      },
{ "testSST_Math_Vec4iNegateLocal                " , testSST_Math_Vec4iNegateLocal                 },
{ "testSST_Math_Vec4iBias                       " , testSST_Math_Vec4iBias                        },
{ "testSST_Math_Vec4iBiasLocal                  " , testSST_Math_Vec4iBiasLocal                   },
{ "testSST_Math_Vec4iMagnitudeSquared           " , testSST_Math_Vec4iMagnitudeSquared            },
{ "testSST_Math_Vec4iDot                        " , testSST_Math_Vec4iDot                         }
};
DECLARE_ZTESTBLOCK(SST_Math_Vec4i)

/******************************************************************************/

static const char* testSST_Math_Vec4iAdd()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = -18;
    x.v[1] = -17;
    x.v[2] = 14;
    x.v[3] = -11;
    y.v[0] = 11;
    y.v[1] = -16;
    y.v[2] = -12;
    y.v[3] = 12;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[-18 -17  14 -11]
[ 11 -16 -12  12]
[ -7 -33   2   1]
*/
    SST_Math_Vec4iAdd(&x,&y,&w);
    TASSERT((w.v[0])==(-7),"Entry _x failed!");
    TASSERT((w.v[1])==(-33),"Entry _y failed!");
    TASSERT((w.v[2])==(2),"Entry _z failed!");
    TASSERT((w.v[3])==(1),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iAddLocal()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 19;
    x.v[1] = -9;
    x.v[2] = -4;
    x.v[3] = -20;
    y.v[0] = -5;
    y.v[1] = 19;
    y.v[2] = -8;
    y.v[3] = 12;
/*
[ 19  -9  -4 -20]
[-5 19 -8 12]
[ 14  10 -12  -8]
*/
    SST_Math_Vec4iAddLocal(&x,&y); /* for accuracy */
    TASSERT((x.v[0])==(14),"Entry _x failed!");
    TASSERT((x.v[1])==(10),"Entry _y failed!");
    TASSERT((x.v[2])==(-12),"Entry _z failed!");
    TASSERT((x.v[3])==(-8),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iSubtract()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = -15;
    x.v[1] = -11;
    x.v[2] = 0;
    x.v[3] = -10;
    y.v[0] = -19;
    y.v[1] = -9;
    y.v[2] = -11;
    y.v[3] = 7;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[-15 -11   0 -10]
[-19  -9 -11   7]
[  4  -2  11 -17]
*/
    SST_Math_Vec4iSubtract(&x,&y,&w);
    TASSERT((w.v[0])==(4),"Entry _x failed!");
    TASSERT((w.v[1])==(-2),"Entry _y failed!");
    TASSERT((w.v[2])==(11),"Entry _z failed!");
    TASSERT((w.v[3])==(-17),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iSubtractLocal()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 3;
    x.v[1] = 8;
    x.v[2] = 17;
    x.v[3] = 1;
    y.v[0] = 11;
    y.v[1] = 6;
    y.v[2] = -2;
    y.v[3] = 19;
/*
[ 3  8 17  1]
[11  6 -2 19]
[ -8   2  19 -18]
*/
    SST_Math_Vec4iSubtractLocal(&x,&y); /* for accuracy */
    TASSERT((x.v[0])==(-8),"Entry _x failed!");
    TASSERT((x.v[1])==(2),"Entry _y failed!");
    TASSERT((x.v[2])==(19),"Entry _z failed!");
    TASSERT((x.v[3])==(-18),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iMultiply()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 0;
    x.v[1] = 9;
    x.v[2] = -18;
    x.v[3] = 9;
    y.v[0] = -17;
    y.v[1] = 0;
    y.v[2] = 8;
    y.v[3] = -12;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[  0   9 -18   9]
[-17   0   8 -12]
[   0    0 -144 -108]
*/
    SST_Math_Vec4iMultiply(&x,&y,&w);
    TASSERT((w.v[0])==(0),"Entry _x failed!");
    TASSERT((w.v[1])==(0),"Entry _y failed!");
    TASSERT((w.v[2])==(-144),"Entry _z failed!");
    TASSERT((w.v[3])==(-108),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iMultiplyLocal()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = -9;
    x.v[1] = 10;
    x.v[2] = -6;
    x.v[3] = -2;
    y.v[0] = 10;
    y.v[1] = 11;
    y.v[2] = -19;
    y.v[3] = 12;
/*
[-9 10 -6 -2]
[ 10  11 -19  12]
[-90 110 114 -24]
*/
    SST_Math_Vec4iMultiplyLocal(&x,&y); /* for accuracy */
    TASSERT((x.v[0])==(-90),"Entry _x failed!");
    TASSERT((x.v[1])==(110),"Entry _y failed!");
    TASSERT((x.v[2])==(114),"Entry _z failed!");
    TASSERT((x.v[3])==(-24),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iDivide()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 28;
    x.v[1] = 34;
    x.v[2] = 37;
    x.v[3] = 21;
    y.v[0] = 39;
    y.v[1] = 16;
    y.v[2] = 22;
    y.v[3] = 26;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[28 34 37 21]
[39 16 22 26]
[0 2 1 0]
*/
    SST_Math_Vec4iDivide(&x,&y,&w);
    TASSERT((w.v[0])==(0),"Entry _x failed!");
    TASSERT((w.v[1])==(2),"Entry _y failed!");
    TASSERT((w.v[2])==(1),"Entry _z failed!");
    TASSERT((w.v[3])==(0),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iDivideLocal()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 12;
    x.v[1] = 36;
    x.v[2] = 30;
    x.v[3] = 7;
    y.v[0] = 38;
    y.v[1] = 16;
    y.v[2] = 28;
    y.v[3] = 3;
/*
[12 36 30  7]
[38 16 28  3]
[0 2 1 2]
*/
    SST_Math_Vec4iDivideLocal(&x,&y); /* for accuracy */
    TASSERT((x.v[0])==(0),"Entry _x failed!");
    TASSERT((x.v[1])==(2),"Entry _y failed!");
    TASSERT((x.v[2])==(1),"Entry _z failed!");
    TASSERT((x.v[3])==(2),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iScale()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = -2;
    x.v[1] = -16;
    x.v[2] = 6;
    x.v[3] = 19;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
    a = 2;
/*
[ -2 -16   6  19]
[ -4 -32  12  38]
*/
    SST_Math_Vec4iScale(&x,a,&w);
    TASSERT((w.v[0])==(-4),"Entry _x failed!");
    TASSERT((w.v[1])==(-32),"Entry _y failed!");
    TASSERT((w.v[2])==(12),"Entry _z failed!");
    TASSERT((w.v[3])==(38),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iScaleLocal()
{
    SST_Vec4i x; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = -1;
    x.v[1] = 16;
    x.v[2] = -20;
    x.v[3] = -6;
    a = 2;
/*
[ -1  16 -20  -6]
[ -2  32 -40 -12]
*/
    SST_Math_Vec4iScaleLocal(&x,a); /* for accuracy */
    TASSERT((x.v[0])==(-2),"Entry _x failed!");
    TASSERT((x.v[1])==(32),"Entry _y failed!");
    TASSERT((x.v[2])==(-40),"Entry _z failed!");
    TASSERT((x.v[3])==(-12),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iAbs()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = -5;
    x.v[1] = 7;
    x.v[2] = -2;
    x.v[3] = -6;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[-5  7 -2 -6]
[5 7 2 6]
*/
    SST_Math_Vec4iAbs(&x,&w);
    TASSERT((w.v[0])==(5),"Entry _x failed!");
    TASSERT((w.v[1])==(7),"Entry _y failed!");
    TASSERT((w.v[2])==(2),"Entry _z failed!");
    TASSERT((w.v[3])==(6),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iAbsLocal()
{
    SST_Vec4i x; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 6;
    x.v[1] = 2;
    x.v[2] = -20;
    x.v[3] = -8;
/*
[  6   2 -20  -8]
[ 6  2 20  8]
*/
    SST_Math_Vec4iAbsLocal(&x); /* for accuracy */
    TASSERT((x.v[0])==(6),"Entry _x failed!");
    TASSERT((x.v[1])==(2),"Entry _y failed!");
    TASSERT((x.v[2])==(20),"Entry _z failed!");
    TASSERT((x.v[3])==(8),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iBias()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = -15;
    x.v[1] = 10;
    x.v[2] = 0;
    x.v[3] = 5;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
    a = -12;
/*
[-15  10   0   5]
[-30  20   0  10]
*/
    SST_Math_Vec4iBias(&x,a,&w);
    TASSERT((w.v[0])==(-27),"Entry _x failed!");
    TASSERT((w.v[1])==(-2),"Entry _y failed!");
    TASSERT((w.v[2])==(-12),"Entry _z failed!");
    TASSERT((w.v[3])==(-7),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iBiasLocal()
{
    SST_Vec4i x; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = 14;
    x.v[1] = 17;
    x.v[2] = -5;
    x.v[3] = -2;
    a = 17;
/*
[14 17 -5 -2]
[ 28  34 -10  -4]
*/
    SST_Math_Vec4iBiasLocal(&x,a); /* for accuracy */
    TASSERT((x.v[0])==(31),"Entry _x failed!");
    TASSERT((x.v[1])==(34),"Entry _y failed!");
    TASSERT((x.v[2])==(12),"Entry _z failed!");
    TASSERT((x.v[3])==(15),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iNegate()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i w; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = -7;
    x.v[1] = 5;
    x.v[2] = 12;
    x.v[3] = -15;
    w.v[0] = 0;
    w.v[1] = 0;
    w.v[2] = 0;
    w.v[3] = 0;
/*
[ -7   5  12 -15]
[  7  -5 -12  15]
*/
    SST_Math_Vec4iNegate(&x,&w);
    TASSERT((w.v[0])==(7),"Entry _x failed!");
    TASSERT((w.v[1])==(-5),"Entry _y failed!");
    TASSERT((w.v[2])==(-12),"Entry _z failed!");
    TASSERT((w.v[3])==(15),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iNegateLocal()
{
    SST_Vec4i x; /* 4 vector */
/* Resetting test vectors */
    x.v[0] = 3;
    x.v[1] = -8;
    x.v[2] = -7;
    x.v[3] = 14;
/*
[ 3 -8 -7 14]
[ -3   8   7 -14]
*/
    SST_Math_Vec4iNegateLocal(&x); /* for accuracy */
    TASSERT((x.v[0])==(-3),"Entry _x failed!");
    TASSERT((x.v[1])==(8),"Entry _y failed!");
    TASSERT((x.v[2])==(7),"Entry _z failed!");
    TASSERT((x.v[3])==(-14),"Entry _w failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iMagnitudeSquared()
{
    SST_Vec4i x; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = 12;
    x.v[1] = 12;
    x.v[2] = -15;
    x.v[3] = 11;
/*
[ 12  12 -15  11]
634
*/
    a = SST_Math_Vec4iMagnitudeSquared(&x);
    TASSERT((a)==(634),"MagnitudeSquared failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

static const char* testSST_Math_Vec4iDot()
{
    SST_Vec4i x; /* 4 vector */
    SST_Vec4i y; /* 4 vector */
    int a; /* scalar */
/* Resetting test vectors */
    x.v[0] = 1;
    x.v[1] = 1;
    x.v[2] = 1;
    x.v[3] = 8;
    y.v[0] = 7;
    y.v[1] = 12;
    y.v[2] = -18;
    y.v[3] = -11;
/*
[1 1 1 8]
-87
*/
    a = SST_Math_Vec4iDot(&x,&y);
    TASSERT((a)==(-87),"Dot failed!");
    return ZTEST_SUCCESS;
}

/******************************************************************************/

