Index: /trunk/psLib/test/dataManip/tst_psRandom.c =================================================================== --- /trunk/psLib/test/dataManip/tst_psRandom.c (revision 4081) +++ /trunk/psLib/test/dataManip/tst_psRandom.c (revision 4082) @@ -34,23 +34,45 @@ psS32 testStatus = true; -psS32 t00() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; - - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc()"); +static psS32 testRandomAlloc(void); +static psS32 testRandomUniform(void); +static psS32 testRandomGaussian(void); +static psS32 testRandomPoisson(void); +static psS32 testRandomResetUniform(void); +static psS32 testRandomResetGaussian(void); +static psS32 testRandomResetPoisson(void); + +testDescription tests[] = { + {testRandomAlloc,000,"psRandomAlloc",0,false}, + {testRandomUniform,000,"psRandomUniform",0,false}, + {testRandomGaussian,000,"psRandomGaussian",0,false}, + {testRandomPoisson,000,"psRandomPoisson",0,false}, + {testRandomResetUniform,000,"psRandomReset",0,false}, + {testRandomResetGaussian,000,"psRandomReset",0,false}, + {testRandomResetPoisson,000,"psRandomReset",0,false}, + {NULL} + }; + +psS32 main(psS32 argc, char* argv[]) +{ + if(!runTestSuite(stderr,"psRandom",tests,argc,argv)) { + return 1; + } + + return 0; +} + +psS32 testRandomAlloc(void) +{ + psRandom *myRNG = NULL; // Valid type allocation myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; } if (myRNG->type != PS_RANDOM_TAUS) { - psError(PS_ERR_UNKNOWN,true,"Did not have the expected type"); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",myRNG->type,PS_RANDOM_TAUS); + return 2; } psFree(myRNG); @@ -61,10 +83,10 @@ psLogSetDestination("dest:stderr"); if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 3; } if (myRNG->type != PS_RANDOM_TAUS) { - psError(PS_ERR_UNKNOWN,true,"Did not have the expected type"); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",myRNG->type,PS_RANDOM_TAUS); + return 4; } psFree(myRNG); @@ -75,5 +97,5 @@ if (myRNG != NULL) { psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type"); - testStatus = false; + return 5; } @@ -82,60 +104,43 @@ if(myRNG == NULL) { psError(PS_ERR_UNKNOWN,true,"Did not return allocated psRandom"); - testStatus = false; - } - psFree(myRNG); - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - printf("ERROR: Memory Leaks! (%d leaks)", memLeaks); - testStatus = false; - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc()", - testStatus); - - return(testStatus); -} - -psS32 t01() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + return 6; + } + psFree(myRNG); + + return 0; +} + +psS32 testRandomUniform(void) +{ + psRandom *myRNG = NULL; psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomUniform()"); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } - + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Initialize vector data with random number for (psS32 i = 0 ; i < NUM_DATA ; i++) { rans->data.F64[i] = psRandomUniform(myRNG); - // printf("%.2f\n", rans->data.F64[i]); - } - stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Mean is %.2f\n", stats->sampleMean); + } + // Perform vector stats on random data (mean, stdev) + stats = psVectorStats(stats, rans, NULL, NULL, 0); stats->options = PS_STAT_SAMPLE_STDEV; stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Standard deviation is %.2f\n", stats->sampleStdev); + // Verify mean and stdev if ((fabs(stats->sampleMean - UNIFORM_MEAN) / UNIFORM_MEAN) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() mean is %.2f, should be %.2f\n", stats->sampleMean, UNIFORM_MEAN); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"psRandomUniform mean is %.2f, should be %.2f", + stats->sampleMean, UNIFORM_MEAN); + return 2; } if ((fabs(stats->sampleStdev - UNIFORM_STDEV) / UNIFORM_STDEV) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() stdev is %.2f, should be %.2f\n", stats->sampleStdev, UNIFORM_STDEV); - testStatus = false; - } - - psMemCheckCorruption(1); + psError(PS_ERR_UNKNOWN,true,"psRandomUniform stdev is %.2f, should be %.2f", + stats->sampleStdev, UNIFORM_STDEV); + return 3; + } + psFree(myRNG); psFree(rans); @@ -145,58 +150,44 @@ if(psRandomUniform(NULL) != 0) { psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - testStatus = false; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomUniform()", - testStatus); - - return(testStatus); -} - -psS32 t02() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + return 4; + } + + return 0; +} + +psS32 testRandomGaussian(void) +{ + psRandom *myRNG = NULL; psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomGaussian()"); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } - + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Initialize vector with random data for (psS32 i = 0 ; i < NUM_DATA ; i++) { rans->data.F64[i] = psRandomGaussian(myRNG); - // printf("%.2f\n", rans->data.F64[i]); - } - stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Mean is %.2f\n", stats->sampleMean); + } + + // Perform vector stats on data (mean, stdev) + stats = psVectorStats(stats, rans, NULL, NULL, 0); stats->options = PS_STAT_SAMPLE_STDEV; stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Standard deviation is %.2f\n", stats->sampleStdev); + + // Verify statistics if ((fabs(stats->sampleMean - GAUSSIAN_MEAN) / 1.0) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() mean is %.2f, should be %.2f\n", stats->sampleMean, GAUSSIAN_MEAN); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"psRandomGaussian mean is %.2f, should be %.2f", + stats->sampleMean, GAUSSIAN_MEAN); + return 2; } if ((fabs(stats->sampleStdev - GAUSSIAN_STDEV) / GAUSSIAN_STDEV) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() stdev is %.2f, should be %.2f\n", stats->sampleStdev, GAUSSIAN_STDEV); - testStatus = false; - } - - psMemCheckCorruption(1); + psError(PS_ERR_UNKNOWN,true,"psRandomGaussian stdev is %.2f, should be %.2f", + stats->sampleStdev, GAUSSIAN_STDEV); + return 3; + } + psFree(myRNG); psFree(rans); @@ -206,59 +197,42 @@ if(psRandomGaussian(NULL) != 0) { psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - testStatus = false; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomGaussian()", - testStatus); - - return(testStatus); -} - -psS32 t03() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + return 4; + } + + return 0; +} + +psS32 testRandomPoisson(void) +{ + psRandom *myRNG = NULL; psVector *rans = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomPoisson()"); - - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } - + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Initialize vector with random data for (psS32 i = 0 ; i < NUM_DATA ; i++) { rans->data.F64[i] = psRandomPoisson(myRNG, POISSON_MEAN); - // printf("%.2f\n", rans->data.F64[i]); - } - stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Mean is %.2f\n", stats->sampleMean); + } + + // Perform statistics on data + stats = psVectorStats(stats, rans, NULL, NULL, 0); stats->options = PS_STAT_SAMPLE_STDEV; stats = psVectorStats(stats, rans, NULL, NULL, 0); - printf("Standard deviation is %.2f\n", stats->sampleStdev); if ((fabs(stats->sampleMean - POISSON_MEAN) / POISSON_MEAN) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() mean is %.2f, should be %.2f\n", stats->sampleMean, POISSON_MEAN); - testStatus = false; + psError(PS_ERR_UNKNOWN,true,"psRandomPoisson mean is %.2f, should be %.2f", + stats->sampleMean, POISSON_MEAN); + return 2; } if ((fabs(stats->sampleStdev - POISSON_STDEV) / POISSON_STDEV) > ERROR_TOLERANCE) { - printf("ERROR: psRandomUniform() stdev is %.2f, should be %.2f\n", stats->sampleStdev, POISSON_STDEV); - testStatus = false; - } - - - psMemCheckCorruption(1); + psError(PS_ERR_UNKNOWN,true,"psRandomPoisson stdev is %.2f, should be %.2f", + stats->sampleStdev, POISSON_STDEV); + return 3; + } + psFree(myRNG); psFree(rans); @@ -268,38 +242,24 @@ if(psRandomPoisson(NULL, POISSON_MEAN) != 0) { psError(PS_ERR_UNKNOWN,true,"Did not return zero for null psRandom"); - testStatus = false; - } - - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc() and psRandomPoisson()", - testStatus); - - return(testStatus); -} - -psS32 t04() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + return 4; + } + + return 0; +} + +psS32 testRandomResetUniform(void) +{ + psRandom *myRNG = NULL; psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomUniform()"); - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Random reset psRandomReset(myRNG, SEED); for (psS32 i = 0 ; i < NUM_DATA ; i++) { @@ -315,11 +275,12 @@ } + // Verify reset to original seed produces same results for (psS32 i = 0 ; i < NUM_DATA ; i++) { if (rans00->data.F64[i] != rans02->data.F64[i]) { - printf("ERROR: psRandomUniform() did not produce the same results with the same seed\n"); + psError(PS_ERR_UNKNOWN,true,"psRandomUniform did not produce the same results with the same seed"); + return i+1; } } - psMemCheckCorruption(1); psFree(myRNG); psFree(rans00); @@ -337,35 +298,21 @@ psRandomReset(NULL,SEED); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomUniform()", - testStatus); - - return(testStatus); -} - -psS32 t05() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + return 0; +} + +psS32 testRandomResetGaussian(void) +{ + psRandom *myRNG = NULL; psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomGaussian()"); - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Initialize random data in vectors psRandomReset(myRNG, SEED); for (psS32 i = 0 ; i < NUM_DATA ; i++) { @@ -381,46 +328,34 @@ } + // Verify data from original seed produces same data after reset for (psS32 i = 0 ; i < NUM_DATA ; i++) { if (rans00->data.F64[i] != rans02->data.F64[i]) { - printf("ERROR: psRandomGaussian() did not produce the same results with the same seed\n"); + psError(PS_ERR_UNKNOWN,true,"psRandomGaussian did not produce the same results with the same seed"); + return 2; } } - psMemCheckCorruption(1); psFree(myRNG); psFree(rans00); psFree(rans01); psFree(rans02); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomGaussian()", - testStatus); - - return(testStatus); -} - -psS32 t06() -{ - psRandom *myRNG = NULL; - psS32 currentId = psMemGetId(); - psS32 memLeaks = 0; + + return 0; +} + +psS32 testRandomResetPoisson(void) +{ + psRandom *myRNG = NULL; psVector *rans00 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans01 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); psVector *rans02 = psVectorAlloc(NUM_DATA, PS_TYPE_F64); - printPositiveTestHeader(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomPoisson()"); - myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); - if (myRNG == NULL) { - printf("ERROR: Could not allocate psRandom structure\n"); - testStatus = false; - } + myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED); + if (myRNG == NULL) { + psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure"); + return 1; + } + + // Initialize vectors with random data psRandomReset(myRNG, SEED); for (psS32 i = 0 ; i < NUM_DATA ; i++) { @@ -436,41 +371,18 @@ } + // Verify the original seed produces same data after reset for (psS32 i = 0 ; i < NUM_DATA ; i++) { if (rans00->data.F64[i] != rans02->data.F64[i]) { - printf("ERROR: psRandomPoisson() did not produce the same results with the same seed\n"); + psError(PS_ERR_UNKNOWN,true,"psRandomPoisson did not produce the same results with the same seed"); + return 2; } } - psMemCheckCorruption(1); psFree(myRNG); psFree(rans00); psFree(rans01); psFree(rans02); - psMemCheckCorruption(1); - memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false); - if (0 != memLeaks) { - psAbort(__func__,"Memory Leaks! (%d leaks)", memLeaks); - } - - printFooter(stdout, - "psRandom functions", - "psRandomAlloc(), psRandomReset(), and psRandomPoisson()", - testStatus); - - return(testStatus); -} - -psS32 main() -{ - testStatus = true; - - t00(); - t01(); - t02(); - t03(); - t04(); - t05(); - t06(); - - return(!testStatus); -} + + return 0; +} + Index: /trunk/psLib/test/dataManip/verified/tst_psRandom.stderr =================================================================== --- /trunk/psLib/test/dataManip/verified/tst_psRandom.stderr (revision 4081) +++ /trunk/psLib/test/dataManip/verified/tst_psRandom.stderr (revision 4082) @@ -1,20 +1,83 @@ -