IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 3286


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

* empty log message *

Location:
trunk/psLib
Files:
1 deleted
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astronomy/psMetadata.c

    r3264 r3286  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-17 19:26:23 $
     14*  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-18 22:17:20 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    344344    }
    345345    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed
    346     psMemDecrRefCounter(metadataItem);
     346    psFree(metadataItem);
    347347
    348348    return true;
    … …  
    453453{ \
    454454    psMetadataItem *metadataItem = NULL; \
     455    ps##TYPE value = 0; \
    455456    \
    456457    if (status) { \
    … …  
    469470        switch (metadataItem->pType) { \
    470471        case PS_TYPE_S32: \
    471             return metadataItem->data.S32; \
     472            value = (ps##TYPE)metadataItem->data.S32; \
     473            break; \
    472474        case PS_TYPE_F32: \
    473             return metadataItem->data.F32; \
     475            value = (ps##TYPE)metadataItem->data.F32; \
     476            break; \
    474477        case PS_TYPE_F64: \
    475             return metadataItem->data.F64; \
     478            value = (ps##TYPE)metadataItem->data.F64; \
     479            break; \
    476480        case PS_TYPE_BOOL: \
    477481            if (metadataItem->data.B) { \
    478                 return 1; \
     482                value = 1; \
    479483            } \
    480             return 0; \
     484            break; \
    481485        default: \
     486            /* if you get to this point, the value is not a number. */ \
     487            if (status) { \
     488                *status = false; \
     489            } \
    482490            break; \
     491        } \
     492    } else { \
     493        if (status) { \
     494            *status = false; \
    483495        } \
    484496    } \
    485497    \
    486     /* if you get to this point, the value is not a number. */ \
    487     if (status) { \
    488         *status = false; \
    489     } \
    490     \
    491     return 0; \
     498    /* psFree(metadataItem); currently, the lookup doesn't increment the ref count */ \
     499    return value; \
    492500}
    493501

  • trunk/psLib/src/collections/psArray.c

    r3264 r3286  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-02-17 19:26:23 $
     11 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-02-18 22:17:20 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    103103
    104104    // add the element to the end of the array.
    105     psArr->data[n] = data;
     105    psArr->data[n] = psMemIncrRefCounter(data);
    106106    psArr->n = n+1;
    107107

  • trunk/psLib/src/collections/psHash.c

    r3264 r3286  
    1212*  @author Robert DeSonia, MHPCC
    1313*
    14 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-17 19:26:23 $
     14*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-18 22:17:20 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/src/collections/psMetadata.c

    r3264 r3286  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-17 19:26:23 $
     14*  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-18 22:17:20 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    344344    }
    345345    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed
    346     psMemDecrRefCounter(metadataItem);
     346    psFree(metadataItem);
    347347
    348348    return true;
    … …  
    453453{ \
    454454    psMetadataItem *metadataItem = NULL; \
     455    ps##TYPE value = 0; \
    455456    \
    456457    if (status) { \
    … …  
    469470        switch (metadataItem->pType) { \
    470471        case PS_TYPE_S32: \
    471             return metadataItem->data.S32; \
     472            value = (ps##TYPE)metadataItem->data.S32; \
     473            break; \
    472474        case PS_TYPE_F32: \
    473             return metadataItem->data.F32; \
     475            value = (ps##TYPE)metadataItem->data.F32; \
     476            break; \
    474477        case PS_TYPE_F64: \
    475             return metadataItem->data.F64; \
     478            value = (ps##TYPE)metadataItem->data.F64; \
     479            break; \
    476480        case PS_TYPE_BOOL: \
    477481            if (metadataItem->data.B) { \
    478                 return 1; \
     482                value = 1; \
    479483            } \
    480             return 0; \
     484            break; \
    481485        default: \
     486            /* if you get to this point, the value is not a number. */ \
     487            if (status) { \
     488                *status = false; \
     489            } \
    482490            break; \
     491        } \
     492    } else { \
     493        if (status) { \
     494            *status = false; \
    483495        } \
    484496    } \
    485497    \
    486     /* if you get to this point, the value is not a number. */ \
    487     if (status) { \
    488         *status = false; \
    489     } \
    490     \
    491     return 0; \
     498    /* psFree(metadataItem); currently, the lookup doesn't increment the ref count */ \
     499    return value; \
    492500}
    493501

  • trunk/psLib/src/types/psArray.c

    r3264 r3286  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-02-17 19:26:23 $
     11 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-02-18 22:17:20 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    103103
    104104    // add the element to the end of the array.
    105     psArr->data[n] = data;
     105    psArr->data[n] = psMemIncrRefCounter(data);
    106106    psArr->n = n+1;
    107107

  • trunk/psLib/src/types/psHash.c

    r3264 r3286  
    1212*  @author Robert DeSonia, MHPCC
    1313*
    14 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-17 19:26:23 $
     14*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-18 22:17:20 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/src/types/psMetadata.c

    r3264 r3286  
    1212*  @author Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2005-02-17 19:26:23 $
     14*  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2005-02-18 22:17:20 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    344344    }
    345345    // Decrement reference count, since the metadata item is now in metadata collection and no longer needed
    346     psMemDecrRefCounter(metadataItem);
     346    psFree(metadataItem);
    347347
    348348    return true;
    … …  
    453453{ \
    454454    psMetadataItem *metadataItem = NULL; \
     455    ps##TYPE value = 0; \
    455456    \
    456457    if (status) { \
    … …  
    469470        switch (metadataItem->pType) { \
    470471        case PS_TYPE_S32: \
    471             return metadataItem->data.S32; \
     472            value = (ps##TYPE)metadataItem->data.S32; \
     473            break; \
    472474        case PS_TYPE_F32: \
    473             return metadataItem->data.F32; \
     475            value = (ps##TYPE)metadataItem->data.F32; \
     476            break; \
    474477        case PS_TYPE_F64: \
    475             return metadataItem->data.F64; \
     478            value = (ps##TYPE)metadataItem->data.F64; \
     479            break; \
    476480        case PS_TYPE_BOOL: \
    477481            if (metadataItem->data.B) { \
    478                 return 1; \
     482                value = 1; \
    479483            } \
    480             return 0; \
     484            break; \
    481485        default: \
     486            /* if you get to this point, the value is not a number. */ \
     487            if (status) { \
     488                *status = false; \
     489            } \
    482490            break; \
     491        } \
     492    } else { \
     493        if (status) { \
     494            *status = false; \
    483495        } \
    484496    } \
    485497    \
    486     /* if you get to this point, the value is not a number. */ \
    487     if (status) { \
    488         *status = false; \
    489     } \
    490     \
    491     return 0; \
     498    /* psFree(metadataItem); currently, the lookup doesn't increment the ref count */ \
     499    return value; \
    492500}
    493501

  • trunk/psLib/test/astronomy/Makefile.am

    r3275 r3286  
    8787
    8888test.psTime.config4: data/test.psTime.config4.template
    89         sed 's|PREFIX|$(srcdir)|' $? > $@
     89        cp $? $@
    9090
    9191test.config: data/test.config
    … …  
    9797header_2.fits: data/header_2.fits
    9898        cp $? $@
     99
     100test.ser7.dat: data/test.ser7.dat
     101        cp $? $@
     102
     103       

  • trunk/psLib/test/astronomy/data/test.psTime.config4.template

    r3246 r3286  
    11# This configuration file specifies values required for time calculations by psLib.
    2 psLib.time.tables.dir STR PREFIX                                                        # Directory for time tables
     2psLib.time.tables.dir STR .                                                             # Directory for time tables
    33psLib.time.tables.n S32 1                                                               # Number of time tables
    44psLib.time.tables.files STR test.ser7.dat                                               # This the table file

  • 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++;

  • trunk/psLib/test/collections/verified/tst_psArray.stderr

    r3127 r3286  
    1 <DATE><TIME>|<HOST>|I|main
     1/***************************** TESTPOINT ******************************************\
     2*             TestFile: tst_psArray.c                                              *
     3*            TestPoint: psArray{psArray}                                           *
     4*             TestType: Positive                                                   *
     5\**********************************************************************************/
     6
     7/***************************** TESTPOINT ******************************************\
     8*             TestFile: tst_psArray.c                                              *
     9*            TestPoint: psArray{Create void pointer array}                         *
     10*             TestType: Positive                                                   *
     11\**********************************************************************************/
     12
     13
     14---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
     15
     16/***************************** TESTPOINT ******************************************\
     17*             TestFile: tst_psArray.c                                              *
     18*            TestPoint: psArray{Add data to void pointer array}                    *
     19*             TestType: Positive                                                   *
     20\**********************************************************************************/
     21
     22ts[0].x = 0 ts[0].y = 0.00
     23ts[1].x = 10 ts[1].y = 10.10
     24ts[2].x = 20 ts[2].y = 20.20
     25ts[3].x = 30 ts[3].y = 30.30
     26ts[4].x = 40 ts[4].y = 40.40
     27array size = 5
     28array population = 5
     29
     30---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
     31
     32/***************************** TESTPOINT ******************************************\
     33*             TestFile: tst_psArray.c                                              *
     34*            TestPoint: psArray{Reallocate void pointer array bigger}              *
     35*             TestType: Positive                                                   *
     36\**********************************************************************************/
     37
     38Adding more elements to void pointer array...
     39ts[0].x = 0 ts[0].y = 0.00
     40ts[1].x = 10 ts[1].y = 10.10
     41ts[2].x = 20 ts[2].y = 20.20
     42ts[3].x = 30 ts[3].y = 30.30
     43ts[4].x = 40 ts[4].y = 40.40
     44ts[5].x = 50 ts[5].y = 50.50
     45ts[6].x = 60 ts[6].y = 60.60
     46ts[7].x = 70 ts[7].y = 70.70
     47ts[8].x = 80 ts[8].y = 80.80
     48ts[9].x = 90 ts[9].y = 90.90
     49array size = 10
     50array population = 10
     51
     52---> TESTPOINT PASSED (psArray{Reallocate void pointer array bigger} | tst_psArray.c)
     53
     54/***************************** TESTPOINT ******************************************\
     55*             TestFile: tst_psArray.c                                              *
     56*            TestPoint: psArray{Reallocate void pointer array smaller}             *
     57*             TestType: Positive                                                   *
     58\**********************************************************************************/
     59
     60ts[0].x = 0 ts[0].y = 0.00
     61ts[1].x = 10 ts[1].y = 10.10
     62ts[2].x = 20 ts[2].y = 20.20
     63array size = 3
     64array population = 3
     65
     66---> TESTPOINT PASSED (psArray{Reallocate integer void pointer smaller} | tst_psArray.c)
     67
     68/***************************** TESTPOINT ******************************************\
     69*             TestFile: tst_psArray.c                                              *
     70*            TestPoint: psArray{Reallocate with a null array}                      *
     71*             TestType: Negative                                                   *
     72*    ExpectedErrorText: Error message generator                                    *
     73*  ExpectedStatusValue: 0                                                          *
     74\**********************************************************************************/
     75
     76<DATE><TIME>|<HOST>|I|testArray
    277    Following should generate an error message.
    378<DATE><TIME>|<HOST>|E|psArrayRealloc (FILE:LINENO)
    479    psArrayRealloc must be given a non-NULL psArray to resize.
     80
     81---> TESTPOINT PASSED (psArray{Reallocate with a null array} | tst_psArray.c)
     82
     83/***************************** TESTPOINT ******************************************\
     84*             TestFile: tst_psArray.c                                              *
     85*            TestPoint: psArray{Remove valid item}                                 *
     86*             TestType: Positive                                                   *
     87\**********************************************************************************/
     88
     89Array size after removal = 2
     90ts[0].x = 10 ts[0].y = 10.10
     91ts[1].x = 20 ts[1].y = 20.20
     92
     93---> TESTPOINT PASSED (psArray{Remove valid item} | tst_psArray.c)
     94
     95/***************************** TESTPOINT ******************************************\
     96*             TestFile: tst_psArray.c                                              *
     97*            TestPoint: psArray{Remove invalid item from array}                    *
     98*             TestType: Positive                                                   *
     99\**********************************************************************************/
     100
     101
     102---> TESTPOINT PASSED (psArray{Remove invalid item from array} | tst_psArray.c)
     103
     104/***************************** TESTPOINT ******************************************\
     105*             TestFile: tst_psArray.c                                              *
     106*            TestPoint: psArray{Remove item from null array}                       *
     107*             TestType: Positive                                                   *
     108\**********************************************************************************/
     109
    5110<DATE><TIME>|<HOST>|E|psArrayRemove (FILE:LINENO)
    6111    Specified psArray can not be NULL.
     112
     113---> TESTPOINT PASSED (psArray{Remove item from null array} | tst_psArray.c)
     114
     115/***************************** TESTPOINT ******************************************\
     116*             TestFile: tst_psArray.c                                              *
     117*            TestPoint: psArray{Remove null item from array}                       *
     118*             TestType: Positive                                                   *
     119\**********************************************************************************/
     120
     121
     122---> TESTPOINT PASSED (psArray{Remove null item from array} | tst_psArray.c)
     123
     124/***************************** TESTPOINT ******************************************\
     125*             TestFile: tst_psArray.c                                              *
     126*            TestPoint: psArray{Free void pointer array}                           *
     127*             TestType: Positive                                                   *
     128\**********************************************************************************/
     129
     130
     131---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
     132
     133
     134---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
     135
     136/***************************** TESTPOINT ******************************************\
     137*             TestFile: tst_psArray.c                                              *
     138*            TestPoint: psArray{psArray}                                           *
     139*             TestType: Positive                                                   *
     140\**********************************************************************************/
     141
     142/***************************** TESTPOINT ******************************************\
     143*             TestFile: tst_psArray.c                                              *
     144*            TestPoint: psArray{Create void pointer array}                         *
     145*             TestType: Positive                                                   *
     146\**********************************************************************************/
     147
     148
     149---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
     150
     151/***************************** TESTPOINT ******************************************\
     152*             TestFile: tst_psArray.c                                              *
     153*            TestPoint: psArray{Add data to void pointer array}                    *
     154*             TestType: Positive                                                   *
     155\**********************************************************************************/
     156
     157ts[0].x = 100 ts[0].y = 101.00
     158ts[1].x = 90 ts[1].y = 90.90
     159ts[2].x = 80 ts[2].y = 80.80
     160ts[3].x = 70 ts[3].y = 70.70
     161ts[4].x = 60 ts[4].y = 60.60
     162ts[5].x = 50 ts[5].y = 50.50
     163ts[6].x = 40 ts[6].y = 40.40
     164ts[7].x = 30 ts[7].y = 30.30
     165ts[8].x = 20 ts[8].y = 20.20
     166ts[9].x = 10 ts[9].y = 10.10
     167array size = 10
     168array population = 10
     169
     170---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
     171
     172/***************************** TESTPOINT ******************************************\
     173*             TestFile: tst_psArray.c                                              *
     174*            TestPoint: psArray{Sort data in array}                                *
     175*             TestType: Positive                                                   *
     176\**********************************************************************************/
     177
     178ts[0].x = 10 ts[0].y = 10.10
     179ts[1].x = 20 ts[1].y = 20.20
     180ts[2].x = 30 ts[2].y = 30.30
     181ts[3].x = 40 ts[3].y = 40.40
     182ts[4].x = 50 ts[4].y = 50.50
     183ts[5].x = 60 ts[5].y = 60.60
     184ts[6].x = 70 ts[6].y = 70.70
     185ts[7].x = 80 ts[7].y = 80.80
     186ts[8].x = 90 ts[8].y = 90.90
     187ts[9].x = 100 ts[9].y = 101.00
     188
     189---> TESTPOINT PASSED (psArray{Sort data in array} | tst_psArray.c)
     190
     191/***************************** TESTPOINT ******************************************\
     192*             TestFile: tst_psArray.c                                              *
     193*            TestPoint: psArray{Attempt to sort array}                             *
     194*             TestType: Positive                                                   *
     195\**********************************************************************************/
     196
     197
     198---> TESTPOINT PASSED (psArray{Attempt to sort array} | tst_psArray.c)
     199
     200/***************************** TESTPOINT ******************************************\
     201*             TestFile: tst_psArray.c                                              *
     202*            TestPoint: psArray{Free void pointer array}                           *
     203*             TestType: Positive                                                   *
     204\**********************************************************************************/
     205
     206
     207---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
     208
     209
     210---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
     211
     212/***************************** TESTPOINT ******************************************\
     213*             TestFile: tst_psArray.c                                              *
     214*            TestPoint: psArray{psArrayAdd}                                        *
     215*             TestType: Positive                                                   *
     216\**********************************************************************************/
     217
     218
     219---> TESTPOINT PASSED (psArray{psArrayAdd} | tst_psArray.c)
     220

  • trunk/psLib/test/dataIO/tst_psFits.c

    r3264 r3286  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-02-17 19:26:25 $
     8*  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-02-18 22:17:20 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    157157    // build a table structure
    158158    psArray* table = psArrayAlloc(tableNumRows);
    159     table->n = 0;
     159    psMetadata* header = NULL;
    160160    for (int row = 0; row < tableNumRows; row++) {
    161         psMetadata* header = psMetadataAlloc();
    162 
     161        header = psMetadataAlloc();
     162
     163        int id = psMemGetId();
    163164        psMetadataAdd(header,PS_LIST_TAIL, "MYINT",
    164165                      PS_TYPE_S32, PS_META_PRIMITIVE,
    165166                      "psS32 Item", (psS32)row);
    166167
     168        fprintf(stderr,"ref=%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data), id);
     169
     170        id = psMemGetId();
    167171        psMetadataAdd(header,PS_LIST_TAIL, "MYFLT",
    168172                      PS_TYPE_F32, PS_META_PRIMITIVE,
    169173                      "psF32 Item", (float)(1.0f/(float)(1+row)));
    170174
     175        fprintf(stderr,"%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data),id);
     176
     177        id = psMemGetId();
    171178        psMetadataAdd(header,PS_LIST_TAIL, "MYDBL",
    172179                      PS_TYPE_F64, PS_META_PRIMITIVE,
    173180                      "psF64 Item", (double)(1.0/(double)(1+row)));
    174181
     182        fprintf(stderr,"%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data),id);
     183
     184        id = psMemGetId();
    175185        psMetadataAdd(header,PS_LIST_TAIL, "MYBOOL",
    176186                      PS_TYPE_BOOL, PS_META_PRIMITIVE,
    … …  
    178188                      (row%2 == 0));
    179189
    180         psArrayAdd(table,0,header);
     190        fprintf(stderr,"%d(%d)\n",(int)psMemGetRefCounter(header->list->tail->data),id);
     191
     192        table->data[row] = header;
    181193    }
    182194
    … …  
    185197    psFree(table);
    186198    psFree(fitsFile);
     199
     200    psMemCheckLeaks(15,NULL,stderr,false);
    187201
    188202    return true;
    … …  
    570584}
    571585
    572 
    573 
    574586static psS32 tst_psFitsReadHeader( void )
    575587{
    … …  
    809821
    810822
    811     if (! makeTable() ) {
     823    if (! makeTable()) {
    812824        return 1;
    813825    }
    … …  
    874886            return 23;
    875887        }
    876 
    877888    }
    878889

  • trunk/psLib/test/fileUtils/tst_psFits.c

    r3264 r3286  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-02-17 19:26:25 $
     8*  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-02-18 22:17:20 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    157157    // build a table structure
    158158    psArray* table = psArrayAlloc(tableNumRows);
    159     table->n = 0;
     159    psMetadata* header = NULL;
    160160    for (int row = 0; row < tableNumRows; row++) {
    161         psMetadata* header = psMetadataAlloc();
    162 
     161        header = psMetadataAlloc();
     162
     163        int id = psMemGetId();
    163164        psMetadataAdd(header,PS_LIST_TAIL, "MYINT",
    164165                      PS_TYPE_S32, PS_META_PRIMITIVE,
    165166                      "psS32 Item", (psS32)row);
    166167
     168        fprintf(stderr,"ref=%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data), id);
     169
     170        id = psMemGetId();
    167171        psMetadataAdd(header,PS_LIST_TAIL, "MYFLT",
    168172                      PS_TYPE_F32, PS_META_PRIMITIVE,
    169173                      "psF32 Item", (float)(1.0f/(float)(1+row)));
    170174
     175        fprintf(stderr,"%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data),id);
     176
     177        id = psMemGetId();
    171178        psMetadataAdd(header,PS_LIST_TAIL, "MYDBL",
    172179                      PS_TYPE_F64, PS_META_PRIMITIVE,
    173180                      "psF64 Item", (double)(1.0/(double)(1+row)));
    174181
     182        fprintf(stderr,"%d(%d), ",(int)psMemGetRefCounter(header->list->tail->data),id);
     183
     184        id = psMemGetId();
    175185        psMetadataAdd(header,PS_LIST_TAIL, "MYBOOL",
    176186                      PS_TYPE_BOOL, PS_META_PRIMITIVE,
    … …  
    178188                      (row%2 == 0));
    179189
    180         psArrayAdd(table,0,header);
     190        fprintf(stderr,"%d(%d)\n",(int)psMemGetRefCounter(header->list->tail->data),id);
     191
     192        table->data[row] = header;
    181193    }
    182194
    … …  
    185197    psFree(table);
    186198    psFree(fitsFile);
     199
     200    psMemCheckLeaks(15,NULL,stderr,false);
    187201
    188202    return true;
    … …  
    570584}
    571585
    572 
    573 
    574586static psS32 tst_psFitsReadHeader( void )
    575587{
    … …  
    809821
    810822
    811     if (! makeTable() ) {
     823    if (! makeTable()) {
    812824        return 1;
    813825    }
    … …  
    874886            return 23;
    875887        }
    876 
    877888    }
    878889
Note: See TracChangeset for help on using the changeset viewer.