IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 10807


Ignore:
Timestamp:
Dec 18, 2006, 9:07:27 AM (20 years ago)
Author:
des
Message:

Added tests to increase coverage.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/mathtypes/tap_psVector.c

    r8841 r10807  
    88int main (void)
    99{
    10     plan_tests(143);
     10    plan_tests(220);
    1111
    1212    diag("psVectorAlloc() tests");
    … …  
    1919        skip_start(psVec == NULL, 4, "Skipping 4 tests because psVectorAlloc() failed");
    2020        ok(psVec->nalloc == 5, "Vector size = %ld", psVec->nalloc);
    21         ok(psVec->n == 0, "Vector population = %ld", psVec->n);
     21        ok(psVec->n == 5, "Vector population = %ld", psVec->n);
    2222        ok(psVec->type.type == PS_TYPE_S32, "Vector type = %d", psVec->type.type);
    2323        ok(psVec->type.dimen == PS_DIMEN_VECTOR, "Vector dimen = %d", psVec->type.dimen);
    … …  
    4747
    4848        skip_start(err == NULL, 2, "Skipping 2 tests because psVectorAlloc() didn't fail as expect");
    49         ok(strstr(err->name, "psVectorAlloc"), "alloc failure - got error name %s", err->name);
     49        ok(strstr(err->name, "vectorAlloc"), "alloc failure - got error name %s", err->name);
    5050        ok(err->code == PS_ERR_BAD_PARAMETER_TYPE, "alloc failure - got error code %d", err->code);
    5151        skip_end();
    … …  
    6060        // create new psVector
    6161        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
     62        ok(psVec->n == 5, "Vector population = %ld", psVec->n);
     63        for(psS32 i = 0; i < 5; i++) {
     64            printf ("Elem %d = %d\n", i, psVec->data.S32[i]);
     65        }
    6266
    6367        // generate first part of vector
    … …  
    6872
    6973        // Test C - Reallocate S32 vector bigger
     74        ok(psVec->n == 5, "Vector population = %ld", psVec->n);
    7075        psVec = psVectorRealloc(psVec,10);
    7176        ok(psVec != NULL, "test vector reallocated to bigger size");
    … …  
    290295
    291296
     297
    292298    diag("psVectorCreate() tests");
     299
     300    {
     301        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S8);
     302        for (int i = 0; i < 10; i++) {
     303            ok(test->data.S8[i] == i, "Vector data matches. i = %d, data=%d",
     304               i, test->data.S8[i]);
     305        }
     306        psFree(test);
     307    }
     308
     309    {
     310        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U8);
     311        for (int i = 0; i < 10; i++) {
     312            ok(test->data.U8[i] == i, "Vector data matches. i = %d, data=%d",
     313               i, test->data.U8[i]);
     314        }
     315        psFree(test);
     316    }
     317
     318
     319    {
     320        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U32);
     321        for (int i = 0; i < 10; i++) {
     322            ok(test->data.U32[i] == i, "Vector data matches. i = %d, data=%d",
     323               i, test->data.U32[i]);
     324        }
     325        psFree(test);
     326    }
     327
    293328
    294329    {
    … …  
    301336    }
    302337
     338
    303339    {
    304340        psVector *input = psVectorAlloc(5, PS_TYPE_F32);
    … …  
    315351    //  Test PS_TYPE_F64
    316352    //       PS_TYPE_S64
     353    //       PS_TYPE_U64
     354
    317355    {
    318356        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S64);
    … …  
    327365
    328366    {
     367        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U64);
     368        for (int i = 0; i < 10; i++)
     369        {
     370            ok(test->data.U64[i] == i,
     371               "Vector data does not match. i = %d, data=%ld",
     372               i, (long)test->data.U64[i]);
     373        }
     374        psFree(test);
     375    }
     376
     377    {
    329378        psVector *input = psVectorAlloc(5, PS_TYPE_F64);
    330379        psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F64);
    … …  
    362411        psFree(input);
    363412    }
     413
     414
     415
     416    diag("psVectorToString() tests");
     417
     418    #define TEST_VECTOR_TO_STRING(TYPE, SIZE, START, INC, EXPECTED)         \
     419    {                                                                       \
     420        const int asize = SIZE;  /* alloc size */                           \
     421        const int osize = 100;   /* output size (max) */                    \
     422        const char* const expected = EXPECTED;                              \
     423        \
     424        psVector *input = psVectorAlloc(asize, TYPE);                       \
     425        psVector *test = psVectorCreate(input, START, START+asize*INC,      \
     426                                        INC, TYPE);                                                     \
     427        \
     428        psString result = psVectorToString(test, osize);                    \
     429        ok(strcmp(result, expected) == 0,                                   \
     430           "psVectorToString expected:result = %s:%s", expected, result ); \
     431        \
     432        psFree(input);                                                      \
     433    }
     434
     435
     436    TEST_VECTOR_TO_STRING(PS_TYPE_U8,  5, 1, 1, "[1,2,3,4,5]");
     437
     438    TEST_VECTOR_TO_STRING(PS_TYPE_U16, 5, 1, 1, "[1,2,3,4,5]");
     439
     440    TEST_VECTOR_TO_STRING(PS_TYPE_U32, 5, 1, 1, "[1,2,3,4,5]");
     441
     442    TEST_VECTOR_TO_STRING(PS_TYPE_U64, 5, 1, 1, "[1,2,3,4,5]");
     443
     444    TEST_VECTOR_TO_STRING(PS_TYPE_S8,  5, -100, 10,"[-100,-90,-80,-70,-60]");
     445
     446    TEST_VECTOR_TO_STRING(PS_TYPE_S16, 5, 0, -100, "[0,-100,-200,-300,-400]");
     447
     448    TEST_VECTOR_TO_STRING(PS_TYPE_S32, 5, 0, -100, "[0,-100,-200,-300,-400]");
     449
     450    TEST_VECTOR_TO_STRING(PS_TYPE_S64, 5, 0, -100, "[0,-100,-200,-300,-400]");
     451
     452    TEST_VECTOR_TO_STRING(PS_TYPE_F32,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
     453    TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
     454
     455    // Must test complex types separately from macro
     456
     457    {
     458        psVector *vec = psVectorAlloc(1, PS_TYPE_C32);
     459        vec->n = 1;
     460        psC32 vC32 = 1.23 + 1.19I;
     461        psVectorInit(vec, vC32);
     462        psString result = psVectorToString(vec, 100);
     463        \
     464        psString expected = "[1.23+1.19i]";
     465        ok(strcmp(result,expected) == 0,                                   \
     466           "psVectorToString expected:result = %s:%s", expected, result );
     467        \
     468        psFree(vec);
     469    }
     470
     471    {
     472        psVector *vec = psVectorAlloc(1, PS_TYPE_C64);
     473        vec->n = 1;
     474        psC64 vC64 = 2.13 + 2.31I;
     475        psVectorInit(vec, vC64);
     476        psString result = psVectorToString(vec, 100);
     477        \
     478        psString expected = "[2.13+2.31i]";
     479        ok(strcmp(result,expected) == 0,                                   \
     480           "psVectorToString expected:result = %s:%s", expected, result );
     481        \
     482        psFree(vec);
     483    }
     484
     485
     486
     487
     488    diag("p_psVectorGetElementF64() tests");
     489
     490    #define TEST_VECTOR_GET_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE,        \
     491                                        INIT_VALUE )                                                        \
     492    {                                                                       \
     493        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
     494        vec->n = SIZE;                                                      \
     495        VALUE_TYPE initValue = INIT_VALUE;                                  \
     496        psVectorInit(vec, initValue);                                       \
     497        psF64 result = p_psVectorGetElementF64(vec, 0);                     \
     498        psF64 expected = (psF64)initValue;                                  \
     499        ok(result == expected,                                              \
     500           "p_psVectorGetElementF64 expected:result = %f:%f",expected,result);\
     501        \
     502        psFree(vec);                                                        \
     503    }
     504
     505    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U8, 1, psU8, 1);
     506
     507    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U16, 2, psU16, 2);
     508
     509    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U32, 3, psU32, 3);
     510
     511    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U64, 100, psU64, 999999);
     512
     513    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S8,  1, psS8, -1);
     514
     515    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S16, 2, psS16, -2);
     516
     517    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S32, 3, psS32, -3);
     518
     519    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S64, 100, psS64, -999999);
     520
     521    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F32,1, psF32, .123);
     522
     523    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123);
     524
     525    // Need different test for complex types since NAN returned.
     526
     527    #define TEST_VECTOR_GET_C_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE,      \
     528                                          INIT_VALUE )                                                        \
     529    {                                                                       \
     530        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
     531        vec->n = SIZE;                                                      \
     532        VALUE_TYPE initValue = INIT_VALUE;                                  \
     533        psVectorInit(vec, initValue);                                       \
     534        psF64 result = p_psVectorGetElementF64(vec, 0);                     \
     535        ok(isnan(result),                                                   \
     536           "p_psVectorGetElementF64 expected NAN/nan got %f", result);     \
     537        \
     538        psFree(vec);                                                        \
     539    }
     540
     541    TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C32,1, psC32, 1.23+1.19I);
     542
     543    TEST_VECTOR_GET_C_ELEMENT_F64(PS_TYPE_C64,100, psC64, -1.23-1.19I);
     544
     545
     546
     547
     548    diag("p_psVectorPrint() tests");
     549
     550    #define TEST_VECTOR_PRINT(ELEM_TYPE, SIZE, VALUE_TYPE, INIT_VALUE, FD,  \
     551                              OUT_NAME, EXPECTED_RC )                                             \
     552    {                                                                       \
     553        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
     554        vec->n = SIZE;                                                      \
     555        VALUE_TYPE initValue = INIT_VALUE;                                  \
     556        psVectorInit(vec, initValue);                                       \
     557        psBool result = p_psVectorPrint(FD, vec, OUT_NAME);                 \
     558        ok(result == EXPECTED_RC,                                           \
     559           "p_psVectorPrint expected:result = %d:%d",EXPECTED_RC,result);  \
     560        \
     561        psFree(vec);                                                        \
     562    }
     563
     564    TEST_VECTOR_PRINT(PS_TYPE_U8, 1, psU8, 1, 1, "PS_TYPE_U8", TRUE);
     565
     566    TEST_VECTOR_PRINT(PS_TYPE_U16, 2, psU16, 2, 1, "PS_TYPE_U16", TRUE);
     567
     568    TEST_VECTOR_PRINT(PS_TYPE_U32, 3, psU32, 3, 1, "PS_TYPE_U32", TRUE);
     569
     570    TEST_VECTOR_PRINT(PS_TYPE_U64, 4, psU64, 999999, 1, "PS_TYPE_U64", TRUE);
     571
     572    TEST_VECTOR_PRINT(PS_TYPE_S8,  1, psS8, -1, 1, "PS_TYPE_S8", TRUE);
     573
     574    TEST_VECTOR_PRINT(PS_TYPE_S16, 2, psS16, -2, 1, "PS_TYPE_S16", TRUE);
     575
     576    TEST_VECTOR_PRINT(PS_TYPE_S32, 3, psS32, -3, 1, "PS_TYPE_S32", TRUE);
     577
     578    TEST_VECTOR_PRINT(PS_TYPE_S64, 4, psS64, -999999, 1, "PS_TYPE_S64", TRUE);
     579
     580    TEST_VECTOR_PRINT(PS_TYPE_F32,1, psF32, .123, 1, "PS_TYPE_F32", TRUE);
     581
     582    TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 1, "PS_TYPE_F64", TRUE);
     583
     584    TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 99, "PS_TYPE_F64", FALSE);
     585
    364586
    365587
Note: See TracChangeset for help on using the changeset viewer.