IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 18, 2005, 12:17:20 PM (21 years ago)
Author:
desonia
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/collections/tst_psArray.c

    r3281 r3286  
    1717 *  @author  Ross Harman, MHPCC
    1818 *
    19  *  @version $Revision: 1.11 $  $Name: not supported by cvs2svn $
    20  *  @date  $Date: 2005-02-18 00:01:39 $
     19 *  @version $Revision: 1.12 $  $Name: not supported by cvs2svn $
     20 *  @date  $Date: 2005-02-18 22:17:20 $
    2121 *
    2222 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7575
    7676    // Test A - Create void pointer array
    77     printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
     77    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
    7878    psArray *psArr = psArrayAlloc(5);
    7979    if (psArr->nalloc != 5) {
    … …  
    8181        return 1;
    8282    }
    83     printFooter(stdout, "psArray", "Create void pointer array", true);
     83    printFooter(stderr, "psArray", "Create void pointer array", true);
    8484
    8585
    8686    // Test B - Add data to void pointer array
    87     printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
     87    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
    8888    for(psS32 i = 0; i < 5; i++) {
    8989        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    9797    for(psS32 i = 0; i < 5; i++) {
    9898        testStruct *ts = (testStruct*)psArr->data[i];
    99         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     99        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    100100        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    101101            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    103103        }
    104104    }
    105     printf("array size = %d\n", psArr->nalloc);
     105    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    106106    if (psArr->nalloc != 5) {
    107107        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    108108        return 3;
    109109    }
    110     printf("array population = %d\n", psArr->n);
     110    fprintf(stderr,"array population = %d\n", psArr->n);
    111111    if (psArr->n != 5) {
    112112        psError(PS_ERR_UNKNOWN, true,"Array population wrong");
    113113        return 4;
    114114    }
    115     printFooter(stdout, "psArray", "Add data to void pointer array", true);
     115    printFooter(stderr, "psArray", "Add data to void pointer array", true);
    116116
    117117
    118118    // Test C - Reallocate void pointer array bigger
    119     printPositiveTestHeader(stdout,"psArray", "Reallocate void pointer array bigger");
     119    printPositiveTestHeader(stderr,"psArray", "Reallocate void pointer array bigger");
    120120    psArr = psArrayRealloc(psArr,10);
    121     printf("Adding more elements to void pointer array...\n");
     121    fprintf(stderr,"Adding more elements to void pointer array...\n");
    122122    for(psS32 i = 5; i < 10; i++) {
    123123        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    131131    for(psS32 i = 0; i < 10; i++) {
    132132        testStruct *ts = (testStruct*)psArr->data[i];
    133         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     133        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    134134        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    135135            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    137137        }
    138138    }
    139     printf("array size = %d\n", psArr->nalloc);
     139    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    140140    if (psArr->nalloc != 10) {
    141141        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    142142        return 6;
    143143    }
    144     printf("array population = %d\n", psArr->n);
     144    fprintf(stderr,"array population = %d\n", psArr->n);
    145145    if (psArr->n != 10) {
    146146        psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
    147147        return 7;
    148148    }
    149     printFooter(stdout, "psArray", "Reallocate void pointer array bigger", true);
     149    printFooter(stderr, "psArray", "Reallocate void pointer array bigger", true);
    150150
    151151    // Test D - Reallocate void pointer array smaller
    152     printPositiveTestHeader(stdout,"psArray","Reallocate void pointer array smaller");
     152    printPositiveTestHeader(stderr,"psArray","Reallocate void pointer array smaller");
    153153    psArr = psArrayRealloc(psArr,3);
    154154    for(psS32 i = 0; i < 3; i++) {
    155155        testStruct *ts = (testStruct*)psArr->data[i];
    156         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     156        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    157157        if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
    158158            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    160160        }
    161161    }
    162     printf("array size = %d\n", psArr->nalloc);
     162    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    163163    if (psArr->nalloc != 3) {
    164164        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    165165        return 9;
    166166    }
    167     printf("array population = %d\n", psArr->n);
     167    fprintf(stderr,"array population = %d\n", psArr->n);
    168168    if (psArr->n != 3) {
    169169        psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
    170170        return 10;
    171171    }
    172     printFooter(stdout, "psArray", "Reallocate integer void pointer smaller", true);
     172    printFooter(stderr, "psArray", "Reallocate integer void pointer smaller", true);
    173173
    174174    // Test E - Reallocate with a null
    175     printNegativeTestHeader(stdout,"psArray","Reallocate with a null array",
     175    printNegativeTestHeader(stderr,"psArray","Reallocate with a null array",
    176176                            "Error message generator", 0 );
    177177    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
    178178    psArr1 = psArrayRealloc(NULL,5);
    179179    if ( psArr1 != NULL ) {
    180         printf("ERROR: Return is not NULL\n");
    181     }
    182     printFooter(stdout,"psArray","Reallocate with a null array",true);
     180        fprintf(stderr,"ERROR: Return is not NULL\n");
     181    }
     182    printFooter(stderr,"psArray","Reallocate with a null array",true);
    183183
    184184
    185185    // Test F - Remove item from array
    186     printPositiveTestHeader(stdout, "psArray", "Remove valid item");
     186    printPositiveTestHeader(stderr, "psArray", "Remove valid item");
    187187    if( !psArrayRemove(psArr,mySt[0]) ) {
    188188        psError(PS_ERR_UNKNOWN,true,"Unable to remove valid item");
    189189        return 100;
    190190    }
    191     printf("Array size after removal = %d\n",psArr->n);
     191    fprintf(stderr,"Array size after removal = %d\n",psArr->n);
    192192    if ( psArr->n != 2 ) {
    193193        psError(PS_ERR_UNKNOWN, true, "Items in array not decremented after removal");
    … …  
    196196    for(psS32 i = 0; i < psArr->n; i++) {
    197197        testStruct *ts = (testStruct*)psArr->data[i];
    198         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     198        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    199199        if(fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
    200200            psError(PS_ERR_UNKNOWN, true, "Elements not as expected after remove.");
    … …  
    203203    }
    204204    psFree(mySt[0]);
    205     printFooter(stdout,"psArray","Remove valid item", true);
     205    printFooter(stderr,"psArray","Remove valid item", true);
    206206
    207207    // Test G - Remove invalid item from array
    208     printPositiveTestHeader(stdout, "psArray", "Remove invalid item from array");
     208    printPositiveTestHeader(stderr, "psArray", "Remove invalid item from array");
    209209    if( psArrayRemove(psArr,mySt[9]) ) {
    210210        psError(PS_ERR_UNKNOWN,true,"Removed invalid item from array");
    211211        return 103;
    212212    }
    213     printFooter(stdout,"psArray","Remove invalid item from array",true);
     213    printFooter(stderr,"psArray","Remove invalid item from array",true);
    214214
    215215    // Test H - Remove item from null array
    216     printPositiveTestHeader(stdout, "psArray", "Remove item from null array");
     216    printPositiveTestHeader(stderr, "psArray", "Remove item from null array");
    217217    if ( psArrayRemove(NULL,mySt[1]) ) {
    218218        psError(PS_ERR_UNKNOWN,true,"Removed valid item from null array");
    219219        return 104;
    220220    }
    221     printFooter(stdout,"psArray","Remove item from null array",true);
     221    printFooter(stderr,"psArray","Remove item from null array",true);
    222222
    223223    // Test I - Remove null item from array
    224     printPositiveTestHeader(stdout, "psArray", "Remove null item from array");
     224    printPositiveTestHeader(stderr, "psArray", "Remove null item from array");
    225225    if( psArrayRemove(psArr,NULL) ) {
    226226        psError(PS_ERR_UNKNOWN,true,"Remove null item from array",true);
    227227        return 105;
    228228    }
    229     printFooter(stdout,"psArray","Remove null item from array",true);
     229    printFooter(stderr,"psArray","Remove null item from array",true);
    230230
    231231    // Test J - Free void pointer array
    232     printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
     232    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
    233233    psFree(psArr);
    234234    for(psS32 i = 0; i < 10; i++) {
    235235        psFree(mySt[i]);
    236236    }
    237     if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
     237    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
    238238        psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
    239239        return 110;
    … …  
    241241    psS32 nBad = psMemCheckCorruption(0);
    242242    if(nBad) {
    243         printf("ERROR: Found %d bad memory blocks\n", nBad);
     243        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
    244244        return 111;
    245245    }
    246     printFooter(stdout, "psArray" ,"Free void pointer array", true);
     246    printFooter(stderr, "psArray" ,"Free void pointer array", true);
    247247
    248248    return 0;
    … …  
    255255
    256256    // Test A - Create void pointer array
    257     printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
     257    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
    258258    psArray *psArr = psArrayAlloc(10);
    259259    if (psArr->nalloc != 10) {
    … …  
    261261        return 1;
    262262    }
    263     printFooter(stdout, "psArray", "Create void pointer array", true);
     263    printFooter(stderr, "psArray", "Create void pointer array", true);
    264264
    265265    // Test B - Add data to void pointer array
    266     printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
     266    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
    267267    for(psS32 i = 0; i < 10; i++) {
    268268        testStruct *ts = psAlloc(sizeof(testStruct));
    … …  
    276276    for(psS32 i = 0; i < 10; i++) {
    277277        testStruct *ts = (testStruct*)psArr->data[i];
    278         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     278        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    279279        if (fabsf(ts->x - 10*(10-i)) > 0.01f || fabsf(ts->y - 10.1*(10-i)) > 0.01f) {
    280280            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    282282        }
    283283    }
    284     printf("array size = %d\n", psArr->nalloc);
     284    fprintf(stderr,"array size = %d\n", psArr->nalloc);
    285285    if (psArr->nalloc != 10) {
    286286        psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
    287287        return 3;
    288288    }
    289     printf("array population = %d\n", psArr->n);
     289    fprintf(stderr,"array population = %d\n", psArr->n);
    290290    if (psArr->n != 10) {
    291291        psError(PS_ERR_UNKNOWN, true,"Array population wrong");
    292292        return 4;
    293293    }
    294     printFooter(stdout, "psArray", "Add data to void pointer array", true);
     294    printFooter(stderr, "psArray", "Add data to void pointer array", true);
    295295
    296296    // Test C - Sort data in array
    297     printPositiveTestHeader(stdout,"psArray","Sort data in array");
     297    printPositiveTestHeader(stderr,"psArray","Sort data in array");
    298298    psArr = psArraySort(psArr,testStructCompare);
    299299    for(psS32 i = 0; i < 10; i++) {
    300300        testStruct *ts = (testStruct*)psArr->data[i];
    301         printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
     301        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
    302302        if (fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
    303303            psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
    … …  
    305305        }
    306306    }
    307     printFooter(stdout,"psArray","Sort data in array",true);
     307    printFooter(stderr,"psArray","Sort data in array",true);
    308308
    309309    // Test D - Attempt to sort null array
    310     printPositiveTestHeader(stdout,"psArray","Attempt to sort array");
     310    printPositiveTestHeader(stderr,"psArray","Attempt to sort array");
    311311    psArray* tempArr = psArraySort(NULL,testStructCompare);
    312312    if(tempArr != NULL) {
    … …  
    314314        return 6;
    315315    }
    316     printFooter(stdout,"psArray","Attempt to sort array",true);
     316    printFooter(stderr,"psArray","Attempt to sort array",true);
    317317
    318318    // Test E - Free void pointer array
    319     printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
     319    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
    320320    psFree(psArr);
    321321    for(psS32 i = 0; i < 10; i++) {
    322322        psFree(mySt[i]);
    323323    }
    324     if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
     324    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
    325325        psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
    326326        return 110;
    … …  
    328328    psS32 nBad = psMemCheckCorruption(0);
    329329    if(nBad) {
    330         printf("ERROR: Found %d bad memory blocks\n", nBad);
     330        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
    331331        return 111;
    332332    }
    333     printFooter(stdout, "psArray" ,"Free void pointer array", true);
     333    printFooter(stderr, "psArray" ,"Free void pointer array", true);
    334334
    335335    return 0;
    … …  
    352352        data = psAlloc(sizeof(float));
    353353        arr = psArrayAdd(arr, delta*2, data); // make delta unique versus next delta used.
     354
     355        subtest++;
     356        if (psMemGetRefCounter(data) != 2) {
     357            // in response of Bug #302
     358            psError(PS_ERR_UNKNOWN, true,
     359                    "psArrayAdd did not increment the data reference count.");
     360            return subtest;
     361        }
     362
     363        psFree(data);
    354364
    355365        subtest++;
    … …  
    381391    data = psAlloc(sizeof(float));
    382392    arr = psArrayAdd(arr, delta, data);
     393    psFree(data);
    383394
    384395    // make sure the array was expanded
    … …  
    411422        data = psAlloc(sizeof(float));
    412423        arr = psArrayAdd(arr, 0, data);
     424        psFree(data);
    413425    }
    414426    nalloc = arr->nalloc;
    … …  
    419431    data = psAlloc(sizeof(float));
    420432    arr = psArrayAdd(arr, 0, data);
     433    psFree(data);
    421434
    422435    subtest++;
Note: See TracChangeset for help on using the changeset viewer.