Index: trunk/psLib/test/mathtypes/tap_psVector.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVector.c (revision 10779) +++ trunk/psLib/test/mathtypes/tap_psVector.c (revision 10807) @@ -8,5 +8,5 @@ int main (void) { - plan_tests(143); + plan_tests(220); diag("psVectorAlloc() tests"); @@ -19,5 +19,5 @@ skip_start(psVec == NULL, 4, "Skipping 4 tests because psVectorAlloc() failed"); ok(psVec->nalloc == 5, "Vector size = %ld", psVec->nalloc); - ok(psVec->n == 0, "Vector population = %ld", psVec->n); + ok(psVec->n == 5, "Vector population = %ld", psVec->n); ok(psVec->type.type == PS_TYPE_S32, "Vector type = %d", psVec->type.type); ok(psVec->type.dimen == PS_DIMEN_VECTOR, "Vector dimen = %d", psVec->type.dimen); @@ -47,5 +47,5 @@ skip_start(err == NULL, 2, "Skipping 2 tests because psVectorAlloc() didn't fail as expect"); - ok(strstr(err->name, "psVectorAlloc"), "alloc failure - got error name %s", err->name); + ok(strstr(err->name, "vectorAlloc"), "alloc failure - got error name %s", err->name); ok(err->code == PS_ERR_BAD_PARAMETER_TYPE, "alloc failure - got error code %d", err->code); skip_end(); @@ -60,4 +60,8 @@ // create new psVector psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); + ok(psVec->n == 5, "Vector population = %ld", psVec->n); + for(psS32 i = 0; i < 5; i++) { + printf ("Elem %d = %d\n", i, psVec->data.S32[i]); + } // generate first part of vector @@ -68,4 +72,5 @@ // Test C - Reallocate S32 vector bigger + ok(psVec->n == 5, "Vector population = %ld", psVec->n); psVec = psVectorRealloc(psVec,10); ok(psVec != NULL, "test vector reallocated to bigger size"); @@ -290,5 +295,35 @@ + diag("psVectorCreate() tests"); + + { + psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S8); + for (int i = 0; i < 10; i++) { + ok(test->data.S8[i] == i, "Vector data matches. i = %d, data=%d", + i, test->data.S8[i]); + } + psFree(test); + } + + { + psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U8); + for (int i = 0; i < 10; i++) { + ok(test->data.U8[i] == i, "Vector data matches. i = %d, data=%d", + i, test->data.U8[i]); + } + psFree(test); + } + + + { + psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U32); + for (int i = 0; i < 10; i++) { + ok(test->data.U32[i] == i, "Vector data matches. i = %d, data=%d", + i, test->data.U32[i]); + } + psFree(test); + } + { @@ -301,4 +336,5 @@ } + { psVector *input = psVectorAlloc(5, PS_TYPE_F32); @@ -315,4 +351,6 @@ // Test PS_TYPE_F64 // PS_TYPE_S64 + // PS_TYPE_U64 + { psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S64); @@ -327,4 +365,15 @@ { + psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U64); + for (int i = 0; i < 10; i++) + { + ok(test->data.U64[i] == i, + "Vector data does not match. i = %d, data=%ld", + i, (long)test->data.U64[i]); + } + psFree(test); + } + + { psVector *input = psVectorAlloc(5, PS_TYPE_F64); psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F64); @@ -362,4 +411,177 @@ psFree(input); } + + + + diag("psVectorToString() tests"); + + #define TEST_VECTOR_TO_STRING(TYPE, SIZE, START, INC, EXPECTED) \ + { \ + const int asize = SIZE; /* alloc size */ \ + const int osize = 100; /* output size (max) */ \ + const char* const expected = EXPECTED; \ + \ + psVector *input = psVectorAlloc(asize, TYPE); \ + psVector *test = psVectorCreate(input, START, START+asize*INC, \ + INC, TYPE); \ + \ + psString result = psVectorToString(test, osize); \ + ok(strcmp(result, expected) == 0, \ + "psVectorToString expected:result = %s:%s", expected, result ); \ + \ + psFree(input); \ + } + + + TEST_VECTOR_TO_STRING(PS_TYPE_U8, 5, 1, 1, "[1,2,3,4,5]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_U16, 5, 1, 1, "[1,2,3,4,5]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_U32, 5, 1, 1, "[1,2,3,4,5]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_U64, 5, 1, 1, "[1,2,3,4,5]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_S8, 5, -100, 10,"[-100,-90,-80,-70,-60]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_S16, 5, 0, -100, "[0,-100,-200,-300,-400]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_S32, 5, 0, -100, "[0,-100,-200,-300,-400]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_S64, 5, 0, -100, "[0,-100,-200,-300,-400]"); + + TEST_VECTOR_TO_STRING(PS_TYPE_F32,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]"); + TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]"); + + // Must test complex types separately from macro + + { + psVector *vec = psVectorAlloc(1, PS_TYPE_C32); + vec->n = 1; + psC32 vC32 = 1.23 + 1.19I; + psVectorInit(vec, vC32); + psString result = psVectorToString(vec, 100); + \ + psString expected = "[1.23+1.19i]"; + ok(strcmp(result,expected) == 0, \ + "psVectorToString expected:result = %s:%s", expected, result ); + \ + psFree(vec); + } + + { + psVector *vec = psVectorAlloc(1, PS_TYPE_C64); + vec->n = 1; + psC64 vC64 = 2.13 + 2.31I; + psVectorInit(vec, vC64); + psString result = psVectorToString(vec, 100); + \ + psString expected = "[2.13+2.31i]"; + ok(strcmp(result,expected) == 0, \ + "psVectorToString expected:result = %s:%s", expected, result ); + \ + psFree(vec); + } + + + + + diag("p_psVectorGetElementF64() tests"); + + #define TEST_VECTOR_GET_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE, \ + INIT_VALUE ) \ + { \ + psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE); \ + vec->n = SIZE; \ + VALUE_TYPE initValue = INIT_VALUE; \ + psVectorInit(vec, initValue); \ + psF64 result = p_psVectorGetElementF64(vec, 0); \ + psF64 expected = (psF64)initValue; \ + ok(result == expected, \ + "p_psVectorGetElementF64 expected:result = %f:%f",expected,result);\ + \ + psFree(vec); \ + } + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U8, 1, psU8, 1); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U16, 2, psU16, 2); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U32, 3, psU32, 3); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U64, 100, psU64, 999999); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S8, 1, psS8, -1); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S16, 2, psS16, -2); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S32, 3, psS32, -3); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S64, 100, psS64, -999999); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F32,1, psF32, .123); + + TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123); + + // Need different test for complex types since NAN returned. + + #define TEST_VECTOR_GET_C_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE, \ + INIT_VALUE ) \ + { \ + psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE); \ + vec->n = SIZE; \ + VALUE_TYPE initValue = INIT_VALUE; \ + psVectorInit(vec, initValue); \ + psF64 result = p_psVectorGetElementF64(vec, 0); \ + ok(isnan(result), \ + "p_psVectorGetElementF64 expected NAN/nan got %f", result); \ + \ + psFree(vec); \ + } + + TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C32,1, psC32, 1.23+1.19I); + + TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C64,100, psC64, -1.23-1.19I); + + + + + diag("p_psVectorPrint() tests"); + + #define TEST_VECTOR_PRINT(ELEM_TYPE, SIZE, VALUE_TYPE, INIT_VALUE, FD, \ + OUT_NAME, EXPECTED_RC ) \ + { \ + psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE); \ + vec->n = SIZE; \ + VALUE_TYPE initValue = INIT_VALUE; \ + psVectorInit(vec, initValue); \ + psBool result = p_psVectorPrint(FD, vec, OUT_NAME); \ + ok(result == EXPECTED_RC, \ + "p_psVectorPrint expected:result = %d:%d",EXPECTED_RC,result); \ + \ + psFree(vec); \ + } + + TEST_VECTOR_PRINT(PS_TYPE_U8, 1, psU8, 1, 1, "PS_TYPE_U8", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_U16, 2, psU16, 2, 1, "PS_TYPE_U16", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_U32, 3, psU32, 3, 1, "PS_TYPE_U32", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_U64, 4, psU64, 999999, 1, "PS_TYPE_U64", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_S8, 1, psS8, -1, 1, "PS_TYPE_S8", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_S16, 2, psS16, -2, 1, "PS_TYPE_S16", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_S32, 3, psS32, -3, 1, "PS_TYPE_S32", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_S64, 4, psS64, -999999, 1, "PS_TYPE_S64", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_F32,1, psF32, .123, 1, "PS_TYPE_F32", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 1, "PS_TYPE_F64", TRUE); + + TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 99, "PS_TYPE_F64", FALSE); +