Index: trunk/psLib/test/dataManip/tst_psStats07.c =================================================================== --- trunk/psLib/test/dataManip/tst_psStats07.c (revision 1281) +++ trunk/psLib/test/dataManip/tst_psStats07.c (revision 1365) @@ -1,6 +1,6 @@ /***************************************************************************** - This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed - by the procedure psArrayStats(). - *****************************************************************************/ + This routine must ensure that PS_STAT_ROBUST_QUARTILE is correctly computed + by the procedure psArrayStats(). +*****************************************************************************/ #include #include "pslib.h" @@ -17,24 +17,24 @@ int main() { - psStats *myStats = NULL; - int testStatus = true; + psStats * myStats = NULL; + int testStatus = true; int globalTestStatus = true; - int i = 0; - psVector *myVector = NULL; - psVector *maskVector= NULL; + int i = 0; + psVector *myVector = NULL; + psVector *maskVector = NULL; // NOTE: These values were calculated by running the function on the data. // A: They must be changed if we adjust the number of data points. // B: We don't really know that they are correct. - int count = 0; - int currentId = psMemGetId(); - int memLeaks = 0; + int count = 0; + int currentId = psMemGetId(); + int memLeaks = 0; float realMeanNoMask = MEAN; float realMedianNoMask = MEAN; float realModeNoMask = MEAN; float realStdevNoMask = STDEV * 0.33; - float realLQNoMask = MEAN - (0.6 * STDEV); - float realUQNoMask = MEAN + (0.6 * STDEV); - float realN50NoMask = (float) N/4; - float realNfitNoMask = (float) N/4; + float realLQNoMask = MEAN - ( 0.6 * STDEV ); + float realUQNoMask = MEAN + ( 0.6 * STDEV ); + float realN50NoMask = ( float ) N / 4; + float realNfitNoMask = ( float ) N / 4; float realMeanWithMask = MEAN; float realMedianWithMask = MEAN; @@ -43,373 +43,373 @@ float realLQWithMask = MEAN; float realUQWithMask = MEAN; - float realN50WithMask = (float) N/4; - float realNfitWithMask = (float) N/4; - - + float realN50WithMask = ( float ) N / 4; + float realNfitWithMask = ( float ) N / 4; + + /*************************************************************************/ /* Allocate and initialize data structures */ /*************************************************************************/ - myStats = psStatsAlloc(PS_STAT_ROBUST_MEAN | - PS_STAT_ROBUST_MEDIAN | - PS_STAT_ROBUST_MODE | - PS_STAT_ROBUST_STDEV | - PS_STAT_ROBUST_QUARTILE); - - maskVector = psVectorAlloc(N, PS_TYPE_U8); + myStats = psStatsAlloc( PS_STAT_ROBUST_MEAN | + PS_STAT_ROBUST_MEDIAN | + PS_STAT_ROBUST_MODE | + PS_STAT_ROBUST_STDEV | + PS_STAT_ROBUST_QUARTILE ); + + maskVector = psVectorAlloc( N, PS_TYPE_U8 ); maskVector->n = N; - myVector = psGaussianDev(MEAN, STDEV, N); + myVector = psGaussianDev( MEAN, STDEV, N ); // Set the mask vector and calculate the expected maximum. - for (i=0;idata.U8[i] = 0; - count++; - } else { - maskVector->data.U8[i] = 1; - } - } + for ( i = 0;i < N;i++ ) { + if ( i < ( N / 2 ) ) { + maskVector->data.U8[ i ] = 0; + count++; + } else { + maskVector->data.U8[ i ] = 1; + } + } /*************************************************************************/ /* Call psVectorStats() with no vector mask. */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask"); - - myStats = psVectorStats(myStats, myVector, NULL, 0); - - printf("The expected Mean was %f; the calculated Mean was %f\n", - realMeanNoMask, myStats->robustMean); - - if (fabs(myStats->robustMean - realMeanNoMask) < (ERROR_TOLERANCE * realMeanNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: no vector mask", - testStatus); - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask"); - - printf("The expected Median was %f; the calculated Median was %f\n", - realMedianNoMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianNoMask) < (ERROR_TOLERANCE * realMedianNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: no vector mask", - testStatus); - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask"); - - - printf("The expected Mode was %f; the calculated Mode was %f\n", - realModeNoMask, myStats->robustMode); - if (fabs(myStats->robustMode - realModeNoMask) < (ERROR_TOLERANCE * realModeNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask"); - - printf("The expected Stdev was %f; the calculated Stdev was %f\n", - realStdevNoMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevNoMask) < (ERROR_TOLERANCE * realStdevNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask"); - - printf("The expected LQ was %f; the calculated LQ was %f\n", - realLQNoMask, myStats->robustLQ); - - if (fabs(myStats->robustLQ - realLQNoMask) < (ERROR_TOLERANCE * realLQNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: no vector mask"); - - printf("The expected UQ was %f; the calculated UQ was %f\n", - realUQNoMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQNoMask) < (ERROR_TOLERANCE * realUQNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask"); - + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust mean: no vector mask" ); + + myStats = psVectorStats( myStats, myVector, NULL, 0 ); + + printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", + realMeanNoMask, myStats->robustMean ); + + if ( fabs( myStats->robustMean - realMeanNoMask ) < ( ERROR_TOLERANCE * realMeanNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust mean: no vector mask", + testStatus ); + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Median: no vector mask" ); + + printf( "The expected Median was %.2f; the calculated Median was %.2f\n", + realMedianNoMask, myStats->robustMedian ); + if ( fabs( myStats->robustMedian - realMedianNoMask ) < ( ERROR_TOLERANCE * realMedianNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Median: no vector mask", + testStatus ); + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Mode: no vector mask" ); + + + printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", + realModeNoMask, myStats->robustMode ); + if ( fabs( myStats->robustMode - realModeNoMask ) < ( ERROR_TOLERANCE * realModeNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Mode: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask" ); + + printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", + realStdevNoMask, myStats->robustStdev ); + if ( fabs( myStats->robustStdev - realStdevNoMask ) < ( ERROR_TOLERANCE * realStdevNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Stdev: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask" ); + + printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", + realLQNoMask, myStats->robustLQ ); + + if ( fabs( myStats->robustLQ - realLQNoMask ) < ( ERROR_TOLERANCE * realLQNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: upper quartile: no vector mask" ); + + printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", + realUQNoMask, myStats->robustUQ ); + if ( fabs( myStats->robustUQ - realUQNoMask ) < ( ERROR_TOLERANCE * realUQNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust N50: no vector mask" ); + // XXX: realN50NoMask = myStats->robustN50; - - printf("The expected N50 was %f; the calculated N50 was %f\n", - realN50NoMask, myStats->robustN50); - if (fabs(myStats->robustN50 - realN50NoMask) < (ERROR_TOLERANCE * realN50NoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: no vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask"); - + + printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n", + realN50NoMask, myStats->robustN50 ); + if ( fabs( myStats->robustN50 - realN50NoMask ) < ( ERROR_TOLERANCE * realN50NoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust N50: no vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask" ); + // XXX: realNfitNoMask = myStats->robustNfit; - - printf("The expected Nfit was %f; the calculated Nfit was %f\n", - realNfitNoMask, myStats->robustNfit); - if (fabs(myStats->robustNfit - realNfitNoMask) < (ERROR_TOLERANCE * realNfitNoMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask", - testStatus); - - - return(0); - + + printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n", + realNfitNoMask, myStats->robustNfit ); + if ( fabs( myStats->robustNfit - realNfitNoMask ) < ( ERROR_TOLERANCE * realNfitNoMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Nfit: no vector mask", + testStatus ); + + + return ( 0 ); + /*************************************************************************/ /* Call psVectorStats() with vector mask. */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask"); - - printf("Calling psVectorStats() on a vector with elements masked.\n"); - myStats = psVectorStats(myStats, myVector, maskVector, 1); - printf("Called psVectorStats() on a vector with elements masked.\n"); - printf("The expected Mean was %f; the calculated Mean was %f\n", - realMeanWithMask, myStats->robustMean); - if (fabs(myStats->robustMean - realMeanWithMask) < (ERROR_TOLERANCE * realMeanWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust mean: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask"); - - printf("The expected Median was %f; the calculated Median was %f\n", - realMedianWithMask, myStats->robustMedian); - if (fabs(myStats->robustMedian - realMedianWithMask) < (ERROR_TOLERANCE * realMedianWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Median: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask"); - - printf("The expected Mode was %f; the calculated Mode was %f\n", - realModeWithMask, myStats->robustMode); - if (fabs(myStats->robustMode - realModeWithMask) < (ERROR_TOLERANCE * realModeWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Mode: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask"); - - printf("The expected Stdev was %f; the calculated Stdev was %f\n", - realStdevWithMask, myStats->robustStdev); - if (fabs(myStats->robustStdev - realStdevWithMask) < (ERROR_TOLERANCE * realStdevWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask"); - - printf("The expected LQ was %f; the calculated LQ was %f\n", - realLQWithMask, myStats->robustLQ); - if (fabs(myStats->robustLQ - realLQWithMask) < (ERROR_TOLERANCE * realLQWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: upper quartile: with vector mask"); - - printf("The expected UQ was %f; the calculated UQ was %f\n", - realUQWithMask, myStats->robustUQ); - if (fabs(myStats->robustUQ - realUQWithMask) < (ERROR_TOLERANCE * realUQWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask"); - - printf("The expected N50 was %f; the calculated N50 was %f\n", - realN50WithMask, myStats->robustN50); - if (fabs(myStats->robustN50 - realN50WithMask) < (ERROR_TOLERANCE * realN50WithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust N50: with vector mask", - testStatus); - - - - printPositiveTestHeader(stdout, - "psStats functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask"); - - printf("The expected Nfit was %f; the calculated Nfit was %f\n", - realNfitWithMask, myStats->robustNfit); - if (fabs(myStats->robustNfit - realNfitWithMask) < (ERROR_TOLERANCE * realNfitWithMask)) { - testStatus = true; - } else { - testStatus = false; - globalTestStatus = false; - } - printFooter(stdout, - "psVector functions", - "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask", - testStatus); - - - + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust mean: with vector mask" ); + + printf( "Calling psVectorStats() on a vector with elements masked.\n" ); + myStats = psVectorStats( myStats, myVector, maskVector, 1 ); + printf( "Called psVectorStats() on a vector with elements masked.\n" ); + printf( "The expected Mean was %.2f; the calculated Mean was %.2f\n", + realMeanWithMask, myStats->robustMean ); + if ( fabs( myStats->robustMean - realMeanWithMask ) < ( ERROR_TOLERANCE * realMeanWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust mean: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Median: with vector mask" ); + + printf( "The expected Median was %.2f; the calculated Median was %.2f\n", + realMedianWithMask, myStats->robustMedian ); + if ( fabs( myStats->robustMedian - realMedianWithMask ) < ( ERROR_TOLERANCE * realMedianWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Median: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Mode: with vector mask" ); + + printf( "The expected Mode was %.2f; the calculated Mode was %.2f\n", + realModeWithMask, myStats->robustMode ); + if ( fabs( myStats->robustMode - realModeWithMask ) < ( ERROR_TOLERANCE * realModeWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Mode: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask" ); + + printf( "The expected Stdev was %.2f; the calculated Stdev was %.2f\n", + realStdevWithMask, myStats->robustStdev ); + if ( fabs( myStats->robustStdev - realStdevWithMask ) < ( ERROR_TOLERANCE * realStdevWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Stdev: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask" ); + + printf( "The expected LQ was %.2f; the calculated LQ was %.2f\n", + realLQWithMask, myStats->robustLQ ); + if ( fabs( myStats->robustLQ - realLQWithMask ) < ( ERROR_TOLERANCE * realLQWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: upper quartile: with vector mask" ); + + printf( "The expected UQ was %.2f; the calculated UQ was %.2f\n", + realUQWithMask, myStats->robustUQ ); + if ( fabs( myStats->robustUQ - realUQWithMask ) < ( ERROR_TOLERANCE * realUQWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: lower quartile: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust N50: with vector mask" ); + + printf( "The expected N50 was %.2f; the calculated N50 was %.2f\n", + realN50WithMask, myStats->robustN50 ); + if ( fabs( myStats->robustN50 - realN50WithMask ) < ( ERROR_TOLERANCE * realN50WithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust N50: with vector mask", + testStatus ); + + + + printPositiveTestHeader( stdout, + "psStats functions", + "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask" ); + + printf( "The expected Nfit was %.2f; the calculated Nfit was %.2f\n", + realNfitWithMask, myStats->robustNfit ); + if ( fabs( myStats->robustNfit - realNfitWithMask ) < ( ERROR_TOLERANCE * realNfitWithMask ) ) { + testStatus = true; + } else { + testStatus = false; + globalTestStatus = false; + } + printFooter( stdout, + "psVector functions", + "PS_STAT_ROBUST_STATS: robust Nfit: with vector mask", + testStatus ); + + + /*************************************************************************/ /* Deallocate data structures */ /*************************************************************************/ - printPositiveTestHeader(stdout, - "psStats functions", - "psStats(): deallocating memory"); - - psFree(myStats); - psFree(myVector); - psFree(maskVector); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,NULL); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psVector functions", - "psStats(): deallocating memory", - testStatus); - - return (!globalTestStatus); + printPositiveTestHeader( stdout, + "psStats functions", + "psStats(): deallocating memory" ); + + psFree( myStats ); + psFree( myVector ); + psFree( maskVector ); + + psMemCheckCorruption( 1 ); + memLeaks = psMemCheckLeaks( currentId, NULL, NULL ); + if ( 0 != memLeaks ) { + psAbort( __func__, "Memory Leaks! (%d leaks)", memLeaks ); + } + + printFooter( stdout, + "psVector functions", + "psStats(): deallocating memory", + testStatus ); + + return ( !globalTestStatus ); }