IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 893


Ignore:
Timestamp:
Jun 6, 2004, 5:14:39 PM (22 years ago)
Author:
gusciora
Message:

...

Location:
trunk/psLib
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psStats.c

    r889 r893  
    8989    }
    9090
     91    // GUS: Verify that this is the correct action.
     92    if (lower > upper) {
     93        //        psAbort(__func__, "psHistogram requested with lower>upper");
     94        return(NULL);
     95    }
     96
    9197    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    9298    newHist->bounds = psVectorAlloc(n+1, PS_TYPE_F32);
    … …  
    115121    psHistogram *newHist = NULL;
    116122    int i;
     123
     124    // GUS: Verify that this is the correct action.
     125    if (bounds == NULL) {
     126        //        psAbort(__func__, "psHistogram requested with NULL bounds");
     127        return(NULL);
     128    }
    117129
    118130    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    … …  
    166178    int binNum = 0;
    167179    int numBins = 0;
     180
     181    // GUS: Verify that this is the correct action.
     182    if (out == NULL) {
     183        //        psAbort(__func__, "psHistogram requested with NULL struct");
     184        return(NULL);
     185    }
     186
     187    // GUS: Verify that this is the correct action.
     188    if (in == NULL) {
     189        //        psAbort(__func__, "psHistogram requested with NULL struct");
     190        return(out);
     191    }
    168192
    169193    numBins = out->nums->n;
    … …  
    10511075{
    10521076    if (in == NULL) {
    1053         psAbort(__func__, "Input data vector (in) was NULL.");
     1077        return(stats);
     1078    }
     1079    if (stats == NULL) {
     1080        return(NULL);
    10541081    }
    10551082

  • trunk/psLib/src/math/psStats.c

    r889 r893  
    8989    }
    9090
     91    // GUS: Verify that this is the correct action.
     92    if (lower > upper) {
     93        //        psAbort(__func__, "psHistogram requested with lower>upper");
     94        return(NULL);
     95    }
     96
    9197    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    9298    newHist->bounds = psVectorAlloc(n+1, PS_TYPE_F32);
    … …  
    115121    psHistogram *newHist = NULL;
    116122    int i;
     123
     124    // GUS: Verify that this is the correct action.
     125    if (bounds == NULL) {
     126        //        psAbort(__func__, "psHistogram requested with NULL bounds");
     127        return(NULL);
     128    }
    117129
    118130    newHist = (psHistogram *) psAlloc(sizeof(psHistogram));
    … …  
    166178    int binNum = 0;
    167179    int numBins = 0;
     180
     181    // GUS: Verify that this is the correct action.
     182    if (out == NULL) {
     183        //        psAbort(__func__, "psHistogram requested with NULL struct");
     184        return(NULL);
     185    }
     186
     187    // GUS: Verify that this is the correct action.
     188    if (in == NULL) {
     189        //        psAbort(__func__, "psHistogram requested with NULL struct");
     190        return(out);
     191    }
    168192
    169193    numBins = out->nums->n;
    … …  
    10511075{
    10521076    if (in == NULL) {
    1053         psAbort(__func__, "Input data vector (in) was NULL.");
     1077        return(stats);
     1078    }
     1079    if (stats == NULL) {
     1080        return(NULL);
    10541081    }
    10551082

  • trunk/psLib/test/dataManip/tst_psHist00.c

    r887 r893  
    77#include "psTest.h"
    88#include "psMemory.h"
    9 #define MISC_FLOAT_NUMBER 345.0
    10 #define MISC_INT_NUMBER 345
    119#define LOWER 20.0
    1210#define UPPER 30.0
    13 #define NUM_BINS 200
    1411
    1512int main()
    … …  
    1916    int memLeaks        = 0;
    2017    int i               = 0;
     18    int nb              = 0;
     19    int numBins         = 0;
    2120    int currentId       = 0;
    2221
    2322    currentId       = psMemGetId();
    24     /*************************************************************************/
    25     /*  Allocate and initialize data structures                      */
    26     /*************************************************************************/
     23    for (nb=0;nb<4;nb++) {
     24        if (nb == 0)
     25            numBins = 1;
     26        if (nb == 1)
     27            numBins = 2;
     28        if (nb == 2)
     29            numBins = 10;
     30        if (nb == 3)
     31            numBins = 20;
     32        /*********************************************************************/
     33        /*  Allocate and initialize data structures                          */
     34        /*********************************************************************/
     35        printPositiveTestHeader(stdout,
     36                                "psStats functions",
     37                                "Allocate the psHistogram structure.");
     38
     39        myHist = psHistogramAlloc(LOWER, UPPER, numBins);
     40
     41        if (myHist->nums->n != numBins) {
     42            printf("ERROR: myHist->nums->n is wrong size (%d)\n", myHist->nums->n);
     43            testStatus = false;
     44        }
     45
     46        if (myHist->bounds->n != numBins+1) {
     47            printf("ERROR: myHist->bounds->n is wrong size (%d)\n", myHist->bounds->n);
     48            testStatus = false;
     49        }
     50
     51        for (i=0;i<numBins;i++) {
     52            if (myHist->nums->data.S32[i] != 0) {
     53                printf("ERROR: myHist->nums->data.S32[%d] not initialized to 0.\n", i);
     54                testStatus = false;
     55            }
     56            myHist->nums->data.S32[i] = 0;
     57        }
     58
     59        if (myHist->minNum != 0) {
     60            printf("ERROR: myHist->minNum is %d\n", myHist->minNum);
     61            testStatus = false;
     62        }
     63
     64        if (myHist->maxNum != 0) {
     65            printf("myHist->maxNum is %d\n", myHist->maxNum);
     66            testStatus = false;
     67        }
     68
     69        if (myHist->uniform != 1) {
     70            printf("ERROR: myHist->uniform is %d\n", myHist->uniform);
     71            testStatus = false;
     72        }
     73
     74        for (i=0;i<numBins;i++) {
     75            printf("Bin number %d bounds: (%f - %f)\n", i,
     76                   myHist->bounds->data.F32[i],
     77                   myHist->bounds->data.F32[i+1]);
     78        }
     79
     80        psMemCheckCorruption(1);
     81        psHistogramFree(myHist);
     82        psMemCheckCorruption(1);
     83
     84        printFooter(stdout,
     85                    "psStats functions",
     86                    "Allocate the psHistogram structure.",
     87                    testStatus);
     88    }
     89
     90
    2791    printPositiveTestHeader(stdout,
    2892                            "psStats functions",
    29                             "Allocate the psHistogram structure.");
     93                            "Allocate the psHistogram structure. (UPPER<LOWER)");
    3094
    31     myHist = psHistogramAlloc(LOWER, UPPER, NUM_BINS);
    32     for (i=0;i<NUM_BINS;i++) {
    33         myHist->nums->data.S32[i] = MISC_INT_NUMBER;
     95    myHist = psHistogramAlloc(UPPER, LOWER, numBins);
     96    if (myHist != NULL) {
     97        printf("ERROR: myHist != NULL\n");
    3498    }
    35     for (i=0;i<NUM_BINS;i++) {
    36         printf("Bin number %d bounds: (%f - %f)\n", i,
    37                myHist->bounds->data.F32[i],
    38                myHist->bounds->data.F32[i+1]);
    39     }
    40     printf("myHist->minNum is %d\n", myHist->minNum);
    41     printf("myHist->maxNum is %d\n", myHist->maxNum);
    42     printf("myHist->uniform is %d\n", myHist->uniform);
    43 
    44     psMemCheckCorruption(1);
    45 
    4699    printFooter(stdout,
    47100                "psStats functions",
    48                 "Allocate the psHistogram structure.",
     101                "Allocate the psHistogram structure. (UPPER<LOWER)",
    49102                testStatus);
    50103
    … …  
    55108                            "psStats functions",
    56109                            "Deallocate the psHistogram structure.");
    57     psHistogramFree(myHist);
    58110
    59111    psMemCheckCorruption(1);

  • trunk/psLib/test/dataManip/tst_psHist01.c

    r887 r893  
    77#include "psTest.h"
    88#include "psMemory.h"
    9 #define MISC_FLOAT_NUMBER 345.0
    10 #define MISC_INT_NUMBER 345
    119#define LOWER 20.0
    1210#define UPPER 30.0
    13 #define NUM_BINS 200
    1411
    1512int main()
    … …  
    2017    int memLeaks        = 0;
    2118    int i               = 0;
     19    int nb              = 0;
     20    int numBins         = 0;
    2221    int currentId       = 0;
    2322
    2423    currentId       = psMemGetId();
     24    for (nb=0;nb<4;nb++) {
     25        if (nb == 0)
     26            numBins = 1;
     27        if (nb == 1)
     28            numBins = 2;
     29        if (nb == 2)
     30            numBins = 10;
     31        if (nb == 3)
     32            numBins = 20;
     33        /*********************************************************************/
     34        /*  Allocate and initialize data structures                          */
     35        /*********************************************************************/
     36        printPositiveTestHeader(stdout,
     37                                "psStats functions",
     38                                "Allocate the psHistogram structure.");
     39        myBounds = psVectorAlloc(numBins+1, PS_TYPE_F32);
     40        myBounds->n = myBounds->nalloc;
     41        for (i=0;i<numBins+1;i++) {
     42            myBounds->data.F32[i] = LOWER + ((UPPER - LOWER) / (float) numBins) *
     43                                    (float) i;
     44        }
     45        myHist = psHistogramAllocGeneric(myBounds);
     46
     47        if (myHist->nums->n != numBins) {
     48            printf("ERROR: myHist->nums->n is wrong size (%d)\n", myHist->nums->n);
     49            testStatus = false;
     50        }
     51
     52        if (myHist->bounds->n != numBins+1) {
     53            printf("ERROR: myHist->bounds->n is wrong size (%d)\n", myHist->bounds->n);
     54            testStatus = false;
     55        }
     56
     57        for (i=0;i<numBins;i++) {
     58            if (myHist->nums->data.S32[i] != 0) {
     59                printf("ERROR: myHist->nums->data.S32[%d] not initialized to 0.\n", i);
     60                testStatus = false;
     61            }
     62            myHist->nums->data.S32[i] = 0;
     63        }
     64
     65        if (myHist->minNum != 0) {
     66            printf("ERROR: myHist->minNum is %d\n", myHist->minNum);
     67            testStatus = false;
     68        }
     69
     70        if (myHist->maxNum != 0) {
     71            printf("myHist->maxNum is %d\n", myHist->maxNum);
     72            testStatus = false;
     73        }
     74
     75        if (myHist->uniform != 0) {
     76            printf("ERROR: myHist->uniform is %d\n", myHist->uniform);
     77            testStatus = false;
     78        }
     79
     80        for (i=0;i<numBins;i++) {
     81            printf("Bin number %d bounds: (%f - %f)\n", i,
     82                   myHist->bounds->data.F32[i],
     83                   myHist->bounds->data.F32[i+1]);
     84        }
     85        psMemCheckCorruption(1);
     86        psHistogramFree(myHist);
     87        psMemCheckCorruption(1);
     88        psVectorFree(myBounds);
     89
     90        printFooter(stdout,
     91                    "psStats functions",
     92                    "Allocate the psHistogram structure.",
     93                    testStatus);
     94    }
    2595    /*************************************************************************/
    26     /*  Allocate and initialize data structures                      */
    27     /*************************************************************************/
    28     printPositiveTestHeader(stdout,
    29                             "psStats functions",
    30                             "Allocate the psHistogram structure.");
    31     myBounds = psVectorAlloc(NUM_BINS+1, PS_TYPE_F32);
    32     myBounds->n = myBounds->nalloc;
    33     for (i=0;i<NUM_BINS+1;i++) {
    34         myBounds->data.F32[i] = LOWER + ((UPPER - LOWER) / (float) NUM_BINS) *
    35                                 (float) i;
    36     }
    37     myHist = psHistogramAllocGeneric(myBounds);
    38 
    39     for (i=0;i<NUM_BINS;i++) {
    40         myHist->nums->data.S32[i] = MISC_INT_NUMBER;
    41     }
    42 
    43     for (i=0;i<NUM_BINS;i++) {
    44         printf("Bin number %d bounds: (%f - %f)\n", i,
    45                myHist->bounds->data.F32[i],
    46                myHist->bounds->data.F32[i+1]);
    47     }
    48     printf("myHist->minNum is %d\n", myHist->minNum);
    49     printf("myHist->maxNum is %d\n", myHist->maxNum);
    50     printf("myHist->uniform is %d\n", myHist->uniform);
    51 
    52     psMemCheckCorruption(1);
    53 
    54     printFooter(stdout,
    55                 "psStats functions",
    56                 "Allocate the psHistogram structure.",
    57                 testStatus);
    58 
    59     /*************************************************************************/
    60     /*  Deallocate data structures                                   */
     96    /*  Deallocate data structures                                           */
    6197    /*************************************************************************/
    6298    printPositiveTestHeader(stdout,
    6399                            "psStats functions",
    64100                            "Deallocate the psHistogram structure.");
    65     psHistogramFree(myHist);
    66     psVectorFree(myBounds);
    67 
    68101    psMemCheckCorruption(1);
    69102    memLeaks = psMemCheckLeaks(currentId,NULL,NULL);

  • trunk/psLib/test/dataManip/tst_psHist02.c

    r887 r893  
    1212#define LOWER 20.0
    1313#define UPPER 30.0
    14 #define NUM_BINS 20
    1514#define NUM_DATA 10000
    1615
    … …  
    1817{
    1918    psHistogram *myHist = NULL;
     19    psHistogram *myHist2= NULL;
    2020    psVector *myData    = NULL;
    2121    psVector *myMask    = NULL;
    2222    int testStatus      = true;
    2323    int memLeaks        = 0;
     24    int nb              = 0;
     25    int numBins         = 0;
    2426    int i               = 0;
    2527    int currentId       = 0;
    … …  
    2729    currentId       = psMemGetId();
    2830
     31    /*********************************************************************/
     32    /*  Allocate and initialize data structures                          */
     33    /*********************************************************************/
    2934    myData = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    3035    myData->n = myData->nalloc;
    … …  
    4247        }
    4348    }
    44     /*************************************************************************/
    45     /*  Allocate and Perform Histogram, no mask                      */
    46     /*************************************************************************/
     49
     50    for (nb=0;nb<4;nb++) {
     51        if (nb == 0)
     52            numBins = 1;
     53        if (nb == 1)
     54            numBins = 2;
     55        if (nb == 2)
     56            numBins = 10;
     57        if (nb == 3)
     58            numBins = 20;
     59
     60        /*********************************************************************/
     61        /*  Allocate and Perform Histogram, no mask                          */
     62        /*********************************************************************/
     63        printPositiveTestHeader(stdout,
     64                                "psStats functions",
     65                                "Allocate and Perform Histogram, no mask");
     66
     67        myHist = psHistogramAlloc(LOWER, UPPER, numBins);
     68        myHist = psHistogramVector(myHist, myData, NULL, 0);
     69
     70        for (i=0;i<numBins;i++) {
     71            printf("Bin number %d bounds: (%f - %f) data (%d)\n", i,
     72                   myHist->bounds->data.F32[i],
     73                   myHist->bounds->data.F32[i+1],
     74                   myHist->nums->data.S32[i]);
     75        }
     76        psMemCheckCorruption(1);
     77        psHistogramFree(myHist);
     78        psMemCheckCorruption(1);
     79
     80        printFooter(stdout,
     81                    "psStats functions",
     82                    "Allocate and Perform Histogram, no mask",
     83                    testStatus);
     84
     85        /*********************************************************************/
     86        /*  Allocate and Perform Histogram with mask                         */
     87        /*********************************************************************/
     88        printPositiveTestHeader(stdout,
     89                                "psStats functions",
     90                                "Allocate and Perform Histogram with mask");
     91
     92        myHist = psHistogramAlloc(LOWER, UPPER, numBins);
     93        myHist = psHistogramVector(myHist, myData, myMask, 1);
     94
     95        for (i=0;i<numBins;i++) {
     96            printf("Bin number %d bounds: (%f - %f) data (%d)\n", i,
     97                   myHist->bounds->data.F32[i],
     98                   myHist->bounds->data.F32[i+1],
     99                   myHist->nums->data.S32[i]);
     100        }
     101        psMemCheckCorruption(1);
     102        psHistogramFree(myHist);
     103        psMemCheckCorruption(1);
     104
     105        printFooter(stdout,
     106                    "psStats functions",
     107                    "Allocate and Perform Histogram with mask",
     108                    testStatus);
     109    }
     110    psVectorFree(myMask);
     111
    47112    printPositiveTestHeader(stdout,
    48113                            "psStats functions",
    49                             "Allocate and Perform Histogram, no mask");
     114                            "Calling psHistogramVector() with various NULL inputs.");
    50115
    51     myHist = psHistogramAlloc(LOWER, UPPER, NUM_BINS);
    52     myHist = psHistogramVector(myHist, myData, NULL, 0);
     116    // Verify the return value is null and program execution doesn't stop,
     117    // if input parameter myHist is null.
    53118
    54     for (i=0;i<NUM_BINS;i++) {
    55         printf("Bin number %d bounds: (%f - %f) data (%d)\n", i,
    56                myHist->bounds->data.F32[i],
    57                myHist->bounds->data.F32[i+1],
    58                myHist->nums->data.S32[i]);
     119    myHist2 = psHistogramVector(NULL, myData, NULL, 0);
     120    if (myHist2 != NULL) {
     121        printf("ERROR: myHist2!=NULL\n");
     122        testStatus = false;
     123    }
     124    psVectorFree(myData);
     125
     126
     127    // Verify the retrun value is the same as the input parameter myHist and
     128    // program execution doesn't stop, if the input parameter myArray is
     129    // null.
     130
     131    myHist = psHistogramAlloc(LOWER, UPPER, numBins);
     132    myHist = psHistogramVector(myHist, NULL, NULL, 0);
     133    if (myHist == NULL) {
     134        printf("ERROR: myHist==NULL\n");
     135        testStatus = false;
    59136    }
    60137    psHistogramFree(myHist);
    61138
     139
     140    // Verify the return value is the same as the input parameter myHist and
     141    // program execution doesn't stop, if the input parameter myArray has no
     142    // elements.
     143    // NOTE: This code segment is commented out because psVectorAlloc returns
     144    // NULL if called with an N element data.
     145    /*
     146    myData = psVectorAlloc(0, PS_TYPE_F32);
     147    myData->n = myData->nalloc;
     148    myHist = psHistogramAlloc(LOWER, UPPER, numBins);
     149    myHist = psHistogramVector(myHist, NULL, NULL, 0);
     150    if (myHist == NULL) {
     151        printf("ERROR: myHist==NULL\n");
     152        testStatus = false;
     153    }
     154    psHistogramFree(myHist);
     155    psVectorFree(myData);
     156    */
    62157    printFooter(stdout,
    63158                "psStats functions",
    64                 "Allocate and Perform Histogram, no mask",
    65                 testStatus);
    66 
    67     /*************************************************************************/
    68     /*  Allocate and Perform Histogram with mask                     */
    69     /*************************************************************************/
    70     printPositiveTestHeader(stdout,
    71                             "psStats functions",
    72                             "Allocate and Perform Histogram with mask");
    73 
    74     myHist = psHistogramAlloc(LOWER, UPPER, NUM_BINS);
    75     myHist = psHistogramVector(myHist, myData, myMask, 1);
    76 
    77     for (i=0;i<NUM_BINS;i++) {
    78         printf("Bin number %d bounds: (%f - %f) data (%d)\n", i,
    79                myHist->bounds->data.F32[i],
    80                myHist->bounds->data.F32[i+1],
    81                myHist->nums->data.S32[i]);
    82     }
    83 
    84     printFooter(stdout,
    85                 "psStats functions",
    86                 "Allocate and Perform Histogram with mask",
     159                "Calling psHistogramVector() with various NULL inputs.",
    87160                testStatus);
    88161
    … …  
    93166                            "psStats functions",
    94167                            "Deallocate the psHistogram structure.");
    95     psHistogramFree(myHist);
    96     psVectorFree(myData);
    97     psVectorFree(myMask);
    98168
    99169    psMemCheckCorruption(1);

  • trunk/psLib/test/dataManip/tst_psStats00.c

    r887 r893  
    1111{
    1212    psStats *myStats    = NULL;
     13    psStats *myStats2    = NULL;
    1314    int testStatus      = true;
    1415    int globalTestStatus = true;
    … …  
    5152        }
    5253    }
     54
     55
    5356    realMeanNoMask /= (float) N;
    5457    realMeanWithMask /= (float) count;
    … …  
    7881
    7982    /*************************************************************************/
    80     /*  Call psVectorStats() with vector mask.                       */
    81     /*************************************************************************/
    82     printPositiveTestHeader(stdout,
    83                             "psStats functions",
    84                             "PS_STAT_SAMPLE_MEAN: with vector mask");
     83    /*  Call psVectorStats() with vector mask=1.                             */
     84    /*************************************************************************/
     85    printPositiveTestHeader(stdout,
     86                            "psStats functions",
     87                            "PS_STAT_SAMPLE_MEAN: with vector mask=1");
    8588
    8689    myStats = psVectorStats(myStats, myVector, maskVector, 1);
    … …  
    97100    printFooter(stdout,
    98101                "psVector functions",
    99                 "PS_STAT_SAMPLE_MEAN: with vector mask",
    100                 testStatus);
    101 
    102     /*************************************************************************/
    103     /*  Deallocate data structures                                   */
     102                "PS_STAT_SAMPLE_MEAN: with vector mask=1",
     103                testStatus);
     104
     105    /*************************************************************************/
     106    /*  Call psVectorStats() with vector mask=2.                             */
     107    /*************************************************************************/
     108    printPositiveTestHeader(stdout,
     109                            "psStats functions",
     110                            "PS_STAT_SAMPLE_MEAN: with vector mask=2");
     111
     112    // Set the mask vector and calculate the expected maximum.
     113    // Set the mask vector.
     114    for (i=0;i<N;i++) {
     115        if (maskVector->data.U8[i] == 1) {
     116            maskVector->data.U8[i] = 2;
     117        }
     118    }
     119
     120    myStats = psVectorStats(myStats, myVector, maskVector, 2);
     121    mean = myStats->sampleMean;
     122    printf("Called psVectorStats() on a vector with last N/2 elements masked.\n");
     123    printf("The expected mean was %f; the calculated mean was %f\n", realMeanWithMask, mean);
     124    if (mean == realMeanWithMask) {
     125        testStatus = true;
     126    } else {
     127        testStatus = false;
     128        globalTestStatus = false;
     129    }
     130
     131    printFooter(stdout,
     132                "psVector functions",
     133                "PS_STAT_SAMPLE_MEAN: with vector mask=2",
     134                testStatus);
     135
     136    /*************************************************************************/
     137    /*  Call psVectorStats() with vector mask=3.                             */
     138    /*************************************************************************/
     139    printPositiveTestHeader(stdout,
     140                            "psStats functions",
     141                            "PS_STAT_SAMPLE_MEAN: with vector mask=3");
     142
     143    // Set the mask vector and calculate the expected maximum.
     144    // Set the mask vector.
     145    for (i=0;i<N;i++) {
     146        if (maskVector->data.U8[i] == 2) {
     147            maskVector->data.U8[i] = 3;
     148        }
     149    }
     150
     151    myStats = psVectorStats(myStats, myVector, maskVector, 3);
     152    mean = myStats->sampleMean;
     153    printf("Called psVectorStats() on a vector with last N/2 elements masked.\n");
     154    printf("The expected mean was %f; the calculated mean was %f\n", realMeanWithMask, mean);
     155    if (mean == realMeanWithMask) {
     156        testStatus = true;
     157    } else {
     158        testStatus = false;
     159        globalTestStatus = false;
     160    }
     161
     162    printFooter(stdout,
     163                "psVector functions",
     164                "PS_STAT_SAMPLE_MEAN: with vector mask=3",
     165                testStatus);
     166    /*************************************************************************/
     167    /*  Call psVectorStats() with NULL inputs.                               */
     168    /*************************************************************************/
     169    printPositiveTestHeader(stdout,
     170                            "psStats functions",
     171                            "PS_STAT_SAMPLE_MEAN: NULL inputs");
     172
     173    myStats = psVectorStats(myStats, NULL, NULL, 0);
     174    myStats2 = psVectorStats(NULL, myVector, NULL, 0);
     175
     176    printFooter(stdout,
     177                "psVector functions",
     178                "PS_STAT_SAMPLE_MEAN: NULL inputs",
     179                testStatus);
     180
     181    /*************************************************************************/
     182    /*  Deallocate data structures                                           */
    104183    /*************************************************************************/
    105184    printPositiveTestHeader(stdout,

  • trunk/psLib/test/dataManip/tst_psStats05.c

    r887 r893  
    7373                testStatus);
    7474
     75
     76
     77    printPositiveTestHeader(stdout,
     78                            "psStats functions",
     79                            "Deallocate NULL psStats structure.");
     80    psStatsFree(NULL);
     81    printFooter(stdout,
     82                "psStats functions",
     83                "Deallocate NULL psStats structure.",
     84                testStatus);
     85
     86
    7587    return (!testStatus);
    7688}

  • trunk/psLib/test/dataManip/verified/tst_psHist00.stdout

    r890 r893  
    55\----------------------------------------------------------------------------------/
    66
    7 Bin number 0 bounds: (20.000000 - 20.049999)
    8 Bin number 1 bounds: (20.049999 - 20.100000)
    9 Bin number 2 bounds: (20.100000 - 20.150000)
    10 Bin number 3 bounds: (20.150000 - 20.200001)
    11 Bin number 4 bounds: (20.200001 - 20.250000)
    12 Bin number 5 bounds: (20.250000 - 20.299999)
    13 Bin number 6 bounds: (20.299999 - 20.350000)
    14 Bin number 7 bounds: (20.350000 - 20.400000)
    15 Bin number 8 bounds: (20.400000 - 20.450001)
    16 Bin number 9 bounds: (20.450001 - 20.500000)
    17 Bin number 10 bounds: (20.500000 - 20.549999)
    18 Bin number 11 bounds: (20.549999 - 20.600000)
    19 Bin number 12 bounds: (20.600000 - 20.650000)
    20 Bin number 13 bounds: (20.650000 - 20.700001)
    21 Bin number 14 bounds: (20.700001 - 20.750000)
    22 Bin number 15 bounds: (20.750000 - 20.799999)
    23 Bin number 16 bounds: (20.799999 - 20.850000)
    24 Bin number 17 bounds: (20.850000 - 20.900000)
    25 Bin number 18 bounds: (20.900000 - 20.950001)
    26 Bin number 19 bounds: (20.950001 - 21.000000)
    27 Bin number 20 bounds: (21.000000 - 21.049999)
    28 Bin number 21 bounds: (21.049999 - 21.100000)
    29 Bin number 22 bounds: (21.100000 - 21.150000)
    30 Bin number 23 bounds: (21.150000 - 21.200001)
    31 Bin number 24 bounds: (21.200001 - 21.250000)
    32 Bin number 25 bounds: (21.250000 - 21.299999)
    33 Bin number 26 bounds: (21.299999 - 21.350000)
    34 Bin number 27 bounds: (21.350000 - 21.400000)
    35 Bin number 28 bounds: (21.400000 - 21.450001)
    36 Bin number 29 bounds: (21.450001 - 21.500000)
    37 Bin number 30 bounds: (21.500000 - 21.549999)
    38 Bin number 31 bounds: (21.549999 - 21.600000)
    39 Bin number 32 bounds: (21.600000 - 21.650000)
    40 Bin number 33 bounds: (21.650000 - 21.700001)
    41 Bin number 34 bounds: (21.700001 - 21.750000)
    42 Bin number 35 bounds: (21.750000 - 21.799999)
    43 Bin number 36 bounds: (21.799999 - 21.850000)
    44 Bin number 37 bounds: (21.850000 - 21.900000)
    45 Bin number 38 bounds: (21.900000 - 21.950001)
    46 Bin number 39 bounds: (21.950001 - 22.000000)
    47 Bin number 40 bounds: (22.000000 - 22.049999)
    48 Bin number 41 bounds: (22.049999 - 22.100000)
    49 Bin number 42 bounds: (22.100000 - 22.150000)
    50 Bin number 43 bounds: (22.150000 - 22.200001)
    51 Bin number 44 bounds: (22.200001 - 22.250000)
    52 Bin number 45 bounds: (22.250000 - 22.299999)
    53 Bin number 46 bounds: (22.299999 - 22.350000)
    54 Bin number 47 bounds: (22.350000 - 22.400000)
    55 Bin number 48 bounds: (22.400000 - 22.450001)
    56 Bin number 49 bounds: (22.450001 - 22.500000)
    57 Bin number 50 bounds: (22.500000 - 22.549999)
    58 Bin number 51 bounds: (22.549999 - 22.600000)
    59 Bin number 52 bounds: (22.600000 - 22.650000)
    60 Bin number 53 bounds: (22.650000 - 22.700001)
    61 Bin number 54 bounds: (22.700001 - 22.750000)
    62 Bin number 55 bounds: (22.750000 - 22.799999)
    63 Bin number 56 bounds: (22.799999 - 22.850000)
    64 Bin number 57 bounds: (22.850000 - 22.900000)
    65 Bin number 58 bounds: (22.900000 - 22.950001)
    66 Bin number 59 bounds: (22.950001 - 23.000000)
    67 Bin number 60 bounds: (23.000000 - 23.049999)
    68 Bin number 61 bounds: (23.049999 - 23.100000)
    69 Bin number 62 bounds: (23.100000 - 23.150000)
    70 Bin number 63 bounds: (23.150000 - 23.200001)
    71 Bin number 64 bounds: (23.200001 - 23.250000)
    72 Bin number 65 bounds: (23.250000 - 23.299999)
    73 Bin number 66 bounds: (23.299999 - 23.350000)
    74 Bin number 67 bounds: (23.350000 - 23.400000)
    75 Bin number 68 bounds: (23.400000 - 23.450001)
    76 Bin number 69 bounds: (23.450001 - 23.500000)
    77 Bin number 70 bounds: (23.500000 - 23.549999)
    78 Bin number 71 bounds: (23.549999 - 23.600000)
    79 Bin number 72 bounds: (23.600000 - 23.650000)
    80 Bin number 73 bounds: (23.650000 - 23.700001)
    81 Bin number 74 bounds: (23.700001 - 23.750000)
    82 Bin number 75 bounds: (23.750000 - 23.799999)
    83 Bin number 76 bounds: (23.799999 - 23.850000)
    84 Bin number 77 bounds: (23.850000 - 23.900000)
    85 Bin number 78 bounds: (23.900000 - 23.950001)
    86 Bin number 79 bounds: (23.950001 - 24.000000)
    87 Bin number 80 bounds: (24.000000 - 24.049999)
    88 Bin number 81 bounds: (24.049999 - 24.100000)
    89 Bin number 82 bounds: (24.100000 - 24.150000)
    90 Bin number 83 bounds: (24.150000 - 24.200001)
    91 Bin number 84 bounds: (24.200001 - 24.250000)
    92 Bin number 85 bounds: (24.250000 - 24.299999)
    93 Bin number 86 bounds: (24.299999 - 24.350000)
    94 Bin number 87 bounds: (24.350000 - 24.400000)
    95 Bin number 88 bounds: (24.400000 - 24.450001)
    96 Bin number 89 bounds: (24.450001 - 24.500000)
    97 Bin number 90 bounds: (24.500000 - 24.549999)
    98 Bin number 91 bounds: (24.549999 - 24.600000)
    99 Bin number 92 bounds: (24.600000 - 24.650000)
    100 Bin number 93 bounds: (24.650000 - 24.700001)
    101 Bin number 94 bounds: (24.700001 - 24.750000)
    102 Bin number 95 bounds: (24.750000 - 24.799999)
    103 Bin number 96 bounds: (24.799999 - 24.850000)
    104 Bin number 97 bounds: (24.850000 - 24.900000)
    105 Bin number 98 bounds: (24.900000 - 24.950001)
    106 Bin number 99 bounds: (24.950001 - 25.000000)
    107 Bin number 100 bounds: (25.000000 - 25.049999)
    108 Bin number 101 bounds: (25.049999 - 25.100000)
    109 Bin number 102 bounds: (25.100000 - 25.150000)
    110 Bin number 103 bounds: (25.150000 - 25.200001)
    111 Bin number 104 bounds: (25.200001 - 25.250000)
    112 Bin number 105 bounds: (25.250000 - 25.299999)
    113 Bin number 106 bounds: (25.299999 - 25.350000)
    114 Bin number 107 bounds: (25.350000 - 25.400000)
    115 Bin number 108 bounds: (25.400000 - 25.450001)
    116 Bin number 109 bounds: (25.450001 - 25.500000)
    117 Bin number 110 bounds: (25.500000 - 25.549999)
    118 Bin number 111 bounds: (25.549999 - 25.600000)
    119 Bin number 112 bounds: (25.600000 - 25.650000)
    120 Bin number 113 bounds: (25.650000 - 25.700001)
    121 Bin number 114 bounds: (25.700001 - 25.750000)
    122 Bin number 115 bounds: (25.750000 - 25.799999)
    123 Bin number 116 bounds: (25.799999 - 25.850000)
    124 Bin number 117 bounds: (25.850000 - 25.900000)
    125 Bin number 118 bounds: (25.900000 - 25.950001)
    126 Bin number 119 bounds: (25.950001 - 26.000000)
    127 Bin number 120 bounds: (26.000000 - 26.049999)
    128 Bin number 121 bounds: (26.049999 - 26.100000)
    129 Bin number 122 bounds: (26.100000 - 26.150000)
    130 Bin number 123 bounds: (26.150000 - 26.200001)
    131 Bin number 124 bounds: (26.200001 - 26.250000)
    132 Bin number 125 bounds: (26.250000 - 26.299999)
    133 Bin number 126 bounds: (26.299999 - 26.350000)
    134 Bin number 127 bounds: (26.350000 - 26.400000)
    135 Bin number 128 bounds: (26.400000 - 26.450001)
    136 Bin number 129 bounds: (26.450001 - 26.500000)
    137 Bin number 130 bounds: (26.500000 - 26.549999)
    138 Bin number 131 bounds: (26.549999 - 26.600000)
    139 Bin number 132 bounds: (26.600000 - 26.650000)
    140 Bin number 133 bounds: (26.650000 - 26.700001)
    141 Bin number 134 bounds: (26.700001 - 26.750000)
    142 Bin number 135 bounds: (26.750000 - 26.799999)
    143 Bin number 136 bounds: (26.799999 - 26.850000)
    144 Bin number 137 bounds: (26.850000 - 26.900000)
    145 Bin number 138 bounds: (26.900000 - 26.950001)
    146 Bin number 139 bounds: (26.950001 - 27.000000)
    147 Bin number 140 bounds: (27.000000 - 27.049999)
    148 Bin number 141 bounds: (27.049999 - 27.100000)
    149 Bin number 142 bounds: (27.100000 - 27.150000)
    150 Bin number 143 bounds: (27.150000 - 27.200001)
    151 Bin number 144 bounds: (27.200001 - 27.250000)
    152 Bin number 145 bounds: (27.250000 - 27.299999)
    153 Bin number 146 bounds: (27.299999 - 27.350000)
    154 Bin number 147 bounds: (27.350000 - 27.400000)
    155 Bin number 148 bounds: (27.400000 - 27.450001)
    156 Bin number 149 bounds: (27.450001 - 27.500000)
    157 Bin number 150 bounds: (27.500000 - 27.549999)
    158 Bin number 151 bounds: (27.549999 - 27.600000)
    159 Bin number 152 bounds: (27.600000 - 27.650000)
    160 Bin number 153 bounds: (27.650000 - 27.700001)
    161 Bin number 154 bounds: (27.700001 - 27.750000)
    162 Bin number 155 bounds: (27.750000 - 27.799999)
    163 Bin number 156 bounds: (27.799999 - 27.850000)
    164 Bin number 157 bounds: (27.850000 - 27.900000)
    165 Bin number 158 bounds: (27.900000 - 27.950001)
    166 Bin number 159 bounds: (27.950001 - 28.000000)
    167 Bin number 160 bounds: (28.000000 - 28.049999)
    168 Bin number 161 bounds: (28.049999 - 28.100000)
    169 Bin number 162 bounds: (28.100000 - 28.150000)
    170 Bin number 163 bounds: (28.150000 - 28.200001)
    171 Bin number 164 bounds: (28.200001 - 28.250000)
    172 Bin number 165 bounds: (28.250000 - 28.299999)
    173 Bin number 166 bounds: (28.299999 - 28.350000)
    174 Bin number 167 bounds: (28.350000 - 28.400000)
    175 Bin number 168 bounds: (28.400000 - 28.450001)
    176 Bin number 169 bounds: (28.450001 - 28.500000)
    177 Bin number 170 bounds: (28.500000 - 28.549999)
    178 Bin number 171 bounds: (28.549999 - 28.600000)
    179 Bin number 172 bounds: (28.600000 - 28.650000)
    180 Bin number 173 bounds: (28.650000 - 28.700001)
    181 Bin number 174 bounds: (28.700001 - 28.750000)
    182 Bin number 175 bounds: (28.750000 - 28.799999)
    183 Bin number 176 bounds: (28.799999 - 28.850000)
    184 Bin number 177 bounds: (28.850000 - 28.900000)
    185 Bin number 178 bounds: (28.900000 - 28.950001)
    186 Bin number 179 bounds: (28.950001 - 29.000000)
    187 Bin number 180 bounds: (29.000000 - 29.049999)
    188 Bin number 181 bounds: (29.049999 - 29.100000)
    189 Bin number 182 bounds: (29.100000 - 29.150000)
    190 Bin number 183 bounds: (29.150000 - 29.200001)
    191 Bin number 184 bounds: (29.200001 - 29.250000)
    192 Bin number 185 bounds: (29.250000 - 29.299999)
    193 Bin number 186 bounds: (29.299999 - 29.350000)
    194 Bin number 187 bounds: (29.350000 - 29.400000)
    195 Bin number 188 bounds: (29.400000 - 29.450001)
    196 Bin number 189 bounds: (29.450001 - 29.500000)
    197 Bin number 190 bounds: (29.500000 - 29.549999)
    198 Bin number 191 bounds: (29.549999 - 29.600000)
    199 Bin number 192 bounds: (29.600000 - 29.650000)
    200 Bin number 193 bounds: (29.650000 - 29.700001)
    201 Bin number 194 bounds: (29.700001 - 29.750000)
    202 Bin number 195 bounds: (29.750000 - 29.799999)
    203 Bin number 196 bounds: (29.799999 - 29.850000)
    204 Bin number 197 bounds: (29.850000 - 29.900000)
    205 Bin number 198 bounds: (29.900000 - 29.950001)
    206 Bin number 199 bounds: (29.950001 - 30.000000)
    207 myHist->minNum is 0
    208 myHist->maxNum is 0
    209 myHist->uniform is 1
     7Bin number 0 bounds: (20.000000 - 30.000000)
    2108
    2119---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist00.c)
     10
     11/----------------------------- TESTPOINT ------------------------------------------\
     12|             TestFile: tst_psHist00.c                                             |
     13|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     14|             TestType: Positive                                                   |
     15\----------------------------------------------------------------------------------/
     16
     17Bin number 0 bounds: (20.000000 - 25.000000)
     18Bin number 1 bounds: (25.000000 - 30.000000)
     19
     20---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist00.c)
     21
     22/----------------------------- TESTPOINT ------------------------------------------\
     23|             TestFile: tst_psHist00.c                                             |
     24|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     25|             TestType: Positive                                                   |
     26\----------------------------------------------------------------------------------/
     27
     28Bin number 0 bounds: (20.000000 - 21.000000)
     29Bin number 1 bounds: (21.000000 - 22.000000)
     30Bin number 2 bounds: (22.000000 - 23.000000)
     31Bin number 3 bounds: (23.000000 - 24.000000)
     32Bin number 4 bounds: (24.000000 - 25.000000)
     33Bin number 5 bounds: (25.000000 - 26.000000)
     34Bin number 6 bounds: (26.000000 - 27.000000)
     35Bin number 7 bounds: (27.000000 - 28.000000)
     36Bin number 8 bounds: (28.000000 - 29.000000)
     37Bin number 9 bounds: (29.000000 - 30.000000)
     38
     39---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist00.c)
     40
     41/----------------------------- TESTPOINT ------------------------------------------\
     42|             TestFile: tst_psHist00.c                                             |
     43|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     44|             TestType: Positive                                                   |
     45\----------------------------------------------------------------------------------/
     46
     47Bin number 0 bounds: (20.000000 - 20.500000)
     48Bin number 1 bounds: (20.500000 - 21.000000)
     49Bin number 2 bounds: (21.000000 - 21.500000)
     50Bin number 3 bounds: (21.500000 - 22.000000)
     51Bin number 4 bounds: (22.000000 - 22.500000)
     52Bin number 5 bounds: (22.500000 - 23.000000)
     53Bin number 6 bounds: (23.000000 - 23.500000)
     54Bin number 7 bounds: (23.500000 - 24.000000)
     55Bin number 8 bounds: (24.000000 - 24.500000)
     56Bin number 9 bounds: (24.500000 - 25.000000)
     57Bin number 10 bounds: (25.000000 - 25.500000)
     58Bin number 11 bounds: (25.500000 - 26.000000)
     59Bin number 12 bounds: (26.000000 - 26.500000)
     60Bin number 13 bounds: (26.500000 - 27.000000)
     61Bin number 14 bounds: (27.000000 - 27.500000)
     62Bin number 15 bounds: (27.500000 - 28.000000)
     63Bin number 16 bounds: (28.000000 - 28.500000)
     64Bin number 17 bounds: (28.500000 - 29.000000)
     65Bin number 18 bounds: (29.000000 - 29.500000)
     66Bin number 19 bounds: (29.500000 - 30.000000)
     67
     68---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist00.c)
     69
     70/----------------------------- TESTPOINT ------------------------------------------\
     71|             TestFile: tst_psHist00.c                                             |
     72|            TestPoint: psStats functions{Allocate the psHistogram structure. (UPPER<LOWER)} |
     73|             TestType: Positive                                                   |
     74\----------------------------------------------------------------------------------/
     75
     76
     77---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure. (UPPER<LOWER)} | tst_psHist00.c)
    21278
    21379/----------------------------- TESTPOINT ------------------------------------------\

  • trunk/psLib/test/dataManip/verified/tst_psHist01.stdout

    r890 r893  
    55\----------------------------------------------------------------------------------/
    66
    7 Bin number 0 bounds: (20.000000 - 20.049999)
    8 Bin number 1 bounds: (20.049999 - 20.100000)
    9 Bin number 2 bounds: (20.100000 - 20.150000)
    10 Bin number 3 bounds: (20.150000 - 20.200001)
    11 Bin number 4 bounds: (20.200001 - 20.250000)
    12 Bin number 5 bounds: (20.250000 - 20.299999)
    13 Bin number 6 bounds: (20.299999 - 20.350000)
    14 Bin number 7 bounds: (20.350000 - 20.400000)
    15 Bin number 8 bounds: (20.400000 - 20.450001)
    16 Bin number 9 bounds: (20.450001 - 20.500000)
    17 Bin number 10 bounds: (20.500000 - 20.549999)
    18 Bin number 11 bounds: (20.549999 - 20.600000)
    19 Bin number 12 bounds: (20.600000 - 20.650000)
    20 Bin number 13 bounds: (20.650000 - 20.700001)
    21 Bin number 14 bounds: (20.700001 - 20.750000)
    22 Bin number 15 bounds: (20.750000 - 20.799999)
    23 Bin number 16 bounds: (20.799999 - 20.850000)
    24 Bin number 17 bounds: (20.850000 - 20.900000)
    25 Bin number 18 bounds: (20.900000 - 20.950001)
    26 Bin number 19 bounds: (20.950001 - 21.000000)
    27 Bin number 20 bounds: (21.000000 - 21.049999)
    28 Bin number 21 bounds: (21.049999 - 21.100000)
    29 Bin number 22 bounds: (21.100000 - 21.150000)
    30 Bin number 23 bounds: (21.150000 - 21.200001)
    31 Bin number 24 bounds: (21.200001 - 21.250000)
    32 Bin number 25 bounds: (21.250000 - 21.299999)
    33 Bin number 26 bounds: (21.299999 - 21.350000)
    34 Bin number 27 bounds: (21.350000 - 21.400000)
    35 Bin number 28 bounds: (21.400000 - 21.450001)
    36 Bin number 29 bounds: (21.450001 - 21.500000)
    37 Bin number 30 bounds: (21.500000 - 21.549999)
    38 Bin number 31 bounds: (21.549999 - 21.600000)
    39 Bin number 32 bounds: (21.600000 - 21.650000)
    40 Bin number 33 bounds: (21.650000 - 21.700001)
    41 Bin number 34 bounds: (21.700001 - 21.750000)
    42 Bin number 35 bounds: (21.750000 - 21.799999)
    43 Bin number 36 bounds: (21.799999 - 21.850000)
    44 Bin number 37 bounds: (21.850000 - 21.900000)
    45 Bin number 38 bounds: (21.900000 - 21.950001)
    46 Bin number 39 bounds: (21.950001 - 22.000000)
    47 Bin number 40 bounds: (22.000000 - 22.049999)
    48 Bin number 41 bounds: (22.049999 - 22.100000)
    49 Bin number 42 bounds: (22.100000 - 22.150000)
    50 Bin number 43 bounds: (22.150000 - 22.200001)
    51 Bin number 44 bounds: (22.200001 - 22.250000)
    52 Bin number 45 bounds: (22.250000 - 22.299999)
    53 Bin number 46 bounds: (22.299999 - 22.350000)
    54 Bin number 47 bounds: (22.350000 - 22.400000)
    55 Bin number 48 bounds: (22.400000 - 22.450001)
    56 Bin number 49 bounds: (22.450001 - 22.500000)
    57 Bin number 50 bounds: (22.500000 - 22.549999)
    58 Bin number 51 bounds: (22.549999 - 22.600000)
    59 Bin number 52 bounds: (22.600000 - 22.650000)
    60 Bin number 53 bounds: (22.650000 - 22.700001)
    61 Bin number 54 bounds: (22.700001 - 22.750000)
    62 Bin number 55 bounds: (22.750000 - 22.799999)
    63 Bin number 56 bounds: (22.799999 - 22.850000)
    64 Bin number 57 bounds: (22.850000 - 22.900000)
    65 Bin number 58 bounds: (22.900000 - 22.950001)
    66 Bin number 59 bounds: (22.950001 - 23.000000)
    67 Bin number 60 bounds: (23.000000 - 23.049999)
    68 Bin number 61 bounds: (23.049999 - 23.100000)
    69 Bin number 62 bounds: (23.100000 - 23.150000)
    70 Bin number 63 bounds: (23.150000 - 23.200001)
    71 Bin number 64 bounds: (23.200001 - 23.250000)
    72 Bin number 65 bounds: (23.250000 - 23.299999)
    73 Bin number 66 bounds: (23.299999 - 23.350000)
    74 Bin number 67 bounds: (23.350000 - 23.400000)
    75 Bin number 68 bounds: (23.400000 - 23.450001)
    76 Bin number 69 bounds: (23.450001 - 23.500000)
    77 Bin number 70 bounds: (23.500000 - 23.549999)
    78 Bin number 71 bounds: (23.549999 - 23.600000)
    79 Bin number 72 bounds: (23.600000 - 23.650000)
    80 Bin number 73 bounds: (23.650000 - 23.700001)
    81 Bin number 74 bounds: (23.700001 - 23.750000)
    82 Bin number 75 bounds: (23.750000 - 23.799999)
    83 Bin number 76 bounds: (23.799999 - 23.850000)
    84 Bin number 77 bounds: (23.850000 - 23.900000)
    85 Bin number 78 bounds: (23.900000 - 23.950001)
    86 Bin number 79 bounds: (23.950001 - 24.000000)
    87 Bin number 80 bounds: (24.000000 - 24.049999)
    88 Bin number 81 bounds: (24.049999 - 24.100000)
    89 Bin number 82 bounds: (24.100000 - 24.150000)
    90 Bin number 83 bounds: (24.150000 - 24.200001)
    91 Bin number 84 bounds: (24.200001 - 24.250000)
    92 Bin number 85 bounds: (24.250000 - 24.299999)
    93 Bin number 86 bounds: (24.299999 - 24.350000)
    94 Bin number 87 bounds: (24.350000 - 24.400000)
    95 Bin number 88 bounds: (24.400000 - 24.450001)
    96 Bin number 89 bounds: (24.450001 - 24.500000)
    97 Bin number 90 bounds: (24.500000 - 24.549999)
    98 Bin number 91 bounds: (24.549999 - 24.600000)
    99 Bin number 92 bounds: (24.600000 - 24.650000)
    100 Bin number 93 bounds: (24.650000 - 24.700001)
    101 Bin number 94 bounds: (24.700001 - 24.750000)
    102 Bin number 95 bounds: (24.750000 - 24.799999)
    103 Bin number 96 bounds: (24.799999 - 24.850000)
    104 Bin number 97 bounds: (24.850000 - 24.900000)
    105 Bin number 98 bounds: (24.900000 - 24.950001)
    106 Bin number 99 bounds: (24.950001 - 25.000000)
    107 Bin number 100 bounds: (25.000000 - 25.049999)
    108 Bin number 101 bounds: (25.049999 - 25.100000)
    109 Bin number 102 bounds: (25.100000 - 25.150000)
    110 Bin number 103 bounds: (25.150000 - 25.200001)
    111 Bin number 104 bounds: (25.200001 - 25.250000)
    112 Bin number 105 bounds: (25.250000 - 25.299999)
    113 Bin number 106 bounds: (25.299999 - 25.350000)
    114 Bin number 107 bounds: (25.350000 - 25.400000)
    115 Bin number 108 bounds: (25.400000 - 25.450001)
    116 Bin number 109 bounds: (25.450001 - 25.500000)
    117 Bin number 110 bounds: (25.500000 - 25.549999)
    118 Bin number 111 bounds: (25.549999 - 25.600000)
    119 Bin number 112 bounds: (25.600000 - 25.650000)
    120 Bin number 113 bounds: (25.650000 - 25.700001)
    121 Bin number 114 bounds: (25.700001 - 25.750000)
    122 Bin number 115 bounds: (25.750000 - 25.799999)
    123 Bin number 116 bounds: (25.799999 - 25.850000)
    124 Bin number 117 bounds: (25.850000 - 25.900000)
    125 Bin number 118 bounds: (25.900000 - 25.950001)
    126 Bin number 119 bounds: (25.950001 - 26.000000)
    127 Bin number 120 bounds: (26.000000 - 26.049999)
    128 Bin number 121 bounds: (26.049999 - 26.100000)
    129 Bin number 122 bounds: (26.100000 - 26.150000)
    130 Bin number 123 bounds: (26.150000 - 26.200001)
    131 Bin number 124 bounds: (26.200001 - 26.250000)
    132 Bin number 125 bounds: (26.250000 - 26.299999)
    133 Bin number 126 bounds: (26.299999 - 26.350000)
    134 Bin number 127 bounds: (26.350000 - 26.400000)
    135 Bin number 128 bounds: (26.400000 - 26.450001)
    136 Bin number 129 bounds: (26.450001 - 26.500000)
    137 Bin number 130 bounds: (26.500000 - 26.549999)
    138 Bin number 131 bounds: (26.549999 - 26.600000)
    139 Bin number 132 bounds: (26.600000 - 26.650000)
    140 Bin number 133 bounds: (26.650000 - 26.700001)
    141 Bin number 134 bounds: (26.700001 - 26.750000)
    142 Bin number 135 bounds: (26.750000 - 26.799999)
    143 Bin number 136 bounds: (26.799999 - 26.850000)
    144 Bin number 137 bounds: (26.850000 - 26.900000)
    145 Bin number 138 bounds: (26.900000 - 26.950001)
    146 Bin number 139 bounds: (26.950001 - 27.000000)
    147 Bin number 140 bounds: (27.000000 - 27.049999)
    148 Bin number 141 bounds: (27.049999 - 27.100000)
    149 Bin number 142 bounds: (27.100000 - 27.150000)
    150 Bin number 143 bounds: (27.150000 - 27.200001)
    151 Bin number 144 bounds: (27.200001 - 27.250000)
    152 Bin number 145 bounds: (27.250000 - 27.299999)
    153 Bin number 146 bounds: (27.299999 - 27.350000)
    154 Bin number 147 bounds: (27.350000 - 27.400000)
    155 Bin number 148 bounds: (27.400000 - 27.450001)
    156 Bin number 149 bounds: (27.450001 - 27.500000)
    157 Bin number 150 bounds: (27.500000 - 27.549999)
    158 Bin number 151 bounds: (27.549999 - 27.600000)
    159 Bin number 152 bounds: (27.600000 - 27.650000)
    160 Bin number 153 bounds: (27.650000 - 27.700001)
    161 Bin number 154 bounds: (27.700001 - 27.750000)
    162 Bin number 155 bounds: (27.750000 - 27.799999)
    163 Bin number 156 bounds: (27.799999 - 27.850000)
    164 Bin number 157 bounds: (27.850000 - 27.900000)
    165 Bin number 158 bounds: (27.900000 - 27.950001)
    166 Bin number 159 bounds: (27.950001 - 28.000000)
    167 Bin number 160 bounds: (28.000000 - 28.049999)
    168 Bin number 161 bounds: (28.049999 - 28.100000)
    169 Bin number 162 bounds: (28.100000 - 28.150000)
    170 Bin number 163 bounds: (28.150000 - 28.200001)
    171 Bin number 164 bounds: (28.200001 - 28.250000)
    172 Bin number 165 bounds: (28.250000 - 28.299999)
    173 Bin number 166 bounds: (28.299999 - 28.350000)
    174 Bin number 167 bounds: (28.350000 - 28.400000)
    175 Bin number 168 bounds: (28.400000 - 28.450001)
    176 Bin number 169 bounds: (28.450001 - 28.500000)
    177 Bin number 170 bounds: (28.500000 - 28.549999)
    178 Bin number 171 bounds: (28.549999 - 28.600000)
    179 Bin number 172 bounds: (28.600000 - 28.650000)
    180 Bin number 173 bounds: (28.650000 - 28.700001)
    181 Bin number 174 bounds: (28.700001 - 28.750000)
    182 Bin number 175 bounds: (28.750000 - 28.799999)
    183 Bin number 176 bounds: (28.799999 - 28.850000)
    184 Bin number 177 bounds: (28.850000 - 28.900000)
    185 Bin number 178 bounds: (28.900000 - 28.950001)
    186 Bin number 179 bounds: (28.950001 - 29.000000)
    187 Bin number 180 bounds: (29.000000 - 29.049999)
    188 Bin number 181 bounds: (29.049999 - 29.100000)
    189 Bin number 182 bounds: (29.100000 - 29.150000)
    190 Bin number 183 bounds: (29.150000 - 29.200001)
    191 Bin number 184 bounds: (29.200001 - 29.250000)
    192 Bin number 185 bounds: (29.250000 - 29.299999)
    193 Bin number 186 bounds: (29.299999 - 29.350000)
    194 Bin number 187 bounds: (29.350000 - 29.400000)
    195 Bin number 188 bounds: (29.400000 - 29.450001)
    196 Bin number 189 bounds: (29.450001 - 29.500000)
    197 Bin number 190 bounds: (29.500000 - 29.549999)
    198 Bin number 191 bounds: (29.549999 - 29.600000)
    199 Bin number 192 bounds: (29.600000 - 29.650000)
    200 Bin number 193 bounds: (29.650000 - 29.700001)
    201 Bin number 194 bounds: (29.700001 - 29.750000)
    202 Bin number 195 bounds: (29.750000 - 29.799999)
    203 Bin number 196 bounds: (29.799999 - 29.850000)
    204 Bin number 197 bounds: (29.850000 - 29.900000)
    205 Bin number 198 bounds: (29.900000 - 29.950001)
    206 Bin number 199 bounds: (29.950001 - 30.000000)
    207 myHist->minNum is 0
    208 myHist->maxNum is 0
    209 myHist->uniform is 0
     7Bin number 0 bounds: (20.000000 - 30.000000)
     8
     9---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist01.c)
     10
     11/----------------------------- TESTPOINT ------------------------------------------\
     12|             TestFile: tst_psHist01.c                                             |
     13|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     14|             TestType: Positive                                                   |
     15\----------------------------------------------------------------------------------/
     16
     17Bin number 0 bounds: (20.000000 - 25.000000)
     18Bin number 1 bounds: (25.000000 - 30.000000)
     19
     20---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist01.c)
     21
     22/----------------------------- TESTPOINT ------------------------------------------\
     23|             TestFile: tst_psHist01.c                                             |
     24|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     25|             TestType: Positive                                                   |
     26\----------------------------------------------------------------------------------/
     27
     28Bin number 0 bounds: (20.000000 - 21.000000)
     29Bin number 1 bounds: (21.000000 - 22.000000)
     30Bin number 2 bounds: (22.000000 - 23.000000)
     31Bin number 3 bounds: (23.000000 - 24.000000)
     32Bin number 4 bounds: (24.000000 - 25.000000)
     33Bin number 5 bounds: (25.000000 - 26.000000)
     34Bin number 6 bounds: (26.000000 - 27.000000)
     35Bin number 7 bounds: (27.000000 - 28.000000)
     36Bin number 8 bounds: (28.000000 - 29.000000)
     37Bin number 9 bounds: (29.000000 - 30.000000)
     38
     39---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist01.c)
     40
     41/----------------------------- TESTPOINT ------------------------------------------\
     42|             TestFile: tst_psHist01.c                                             |
     43|            TestPoint: psStats functions{Allocate the psHistogram structure.}     |
     44|             TestType: Positive                                                   |
     45\----------------------------------------------------------------------------------/
     46
     47Bin number 0 bounds: (20.000000 - 20.500000)
     48Bin number 1 bounds: (20.500000 - 21.000000)
     49Bin number 2 bounds: (21.000000 - 21.500000)
     50Bin number 3 bounds: (21.500000 - 22.000000)
     51Bin number 4 bounds: (22.000000 - 22.500000)
     52Bin number 5 bounds: (22.500000 - 23.000000)
     53Bin number 6 bounds: (23.000000 - 23.500000)
     54Bin number 7 bounds: (23.500000 - 24.000000)
     55Bin number 8 bounds: (24.000000 - 24.500000)
     56Bin number 9 bounds: (24.500000 - 25.000000)
     57Bin number 10 bounds: (25.000000 - 25.500000)
     58Bin number 11 bounds: (25.500000 - 26.000000)
     59Bin number 12 bounds: (26.000000 - 26.500000)
     60Bin number 13 bounds: (26.500000 - 27.000000)
     61Bin number 14 bounds: (27.000000 - 27.500000)
     62Bin number 15 bounds: (27.500000 - 28.000000)
     63Bin number 16 bounds: (28.000000 - 28.500000)
     64Bin number 17 bounds: (28.500000 - 29.000000)
     65Bin number 18 bounds: (29.000000 - 29.500000)
     66Bin number 19 bounds: (29.500000 - 30.000000)
    21067
    21168---> TESTPOINT PASSED (psStats functions{Allocate the psHistogram structure.} | tst_psHist01.c)

  • trunk/psLib/test/dataManip/verified/tst_psHist02.stdout

    r890 r893  
     1/----------------------------- TESTPOINT ------------------------------------------\
     2|             TestFile: tst_psHist02.c                                             |
     3|            TestPoint: psStats functions{Allocate and Perform Histogram, no mask} |
     4|             TestType: Positive                                                   |
     5\----------------------------------------------------------------------------------/
     6
     7Bin number 0 bounds: (20.000000 - 30.000000) data (10000)
     8
     9---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
     10
     11/----------------------------- TESTPOINT ------------------------------------------\
     12|             TestFile: tst_psHist02.c                                             |
     13|            TestPoint: psStats functions{Allocate and Perform Histogram with mask} |
     14|             TestType: Positive                                                   |
     15\----------------------------------------------------------------------------------/
     16
     17Bin number 0 bounds: (20.000000 - 30.000000) data (5000)
     18
     19---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
     20
     21/----------------------------- TESTPOINT ------------------------------------------\
     22|             TestFile: tst_psHist02.c                                             |
     23|            TestPoint: psStats functions{Allocate and Perform Histogram, no mask} |
     24|             TestType: Positive                                                   |
     25\----------------------------------------------------------------------------------/
     26
     27Bin number 0 bounds: (20.000000 - 25.000000) data (5000)
     28Bin number 1 bounds: (25.000000 - 30.000000) data (5000)
     29
     30---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
     31
     32/----------------------------- TESTPOINT ------------------------------------------\
     33|             TestFile: tst_psHist02.c                                             |
     34|            TestPoint: psStats functions{Allocate and Perform Histogram with mask} |
     35|             TestType: Positive                                                   |
     36\----------------------------------------------------------------------------------/
     37
     38Bin number 0 bounds: (20.000000 - 25.000000) data (5000)
     39Bin number 1 bounds: (25.000000 - 30.000000) data (0)
     40
     41---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
     42
     43/----------------------------- TESTPOINT ------------------------------------------\
     44|             TestFile: tst_psHist02.c                                             |
     45|            TestPoint: psStats functions{Allocate and Perform Histogram, no mask} |
     46|             TestType: Positive                                                   |
     47\----------------------------------------------------------------------------------/
     48
     49Bin number 0 bounds: (20.000000 - 21.000000) data (1000)
     50Bin number 1 bounds: (21.000000 - 22.000000) data (1000)
     51Bin number 2 bounds: (22.000000 - 23.000000) data (1000)
     52Bin number 3 bounds: (23.000000 - 24.000000) data (1000)
     53Bin number 4 bounds: (24.000000 - 25.000000) data (1000)
     54Bin number 5 bounds: (25.000000 - 26.000000) data (1000)
     55Bin number 6 bounds: (26.000000 - 27.000000) data (1000)
     56Bin number 7 bounds: (27.000000 - 28.000000) data (1000)
     57Bin number 8 bounds: (28.000000 - 29.000000) data (1000)
     58Bin number 9 bounds: (29.000000 - 30.000000) data (1000)
     59
     60---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram, no mask} | tst_psHist02.c)
     61
     62/----------------------------- TESTPOINT ------------------------------------------\
     63|             TestFile: tst_psHist02.c                                             |
     64|            TestPoint: psStats functions{Allocate and Perform Histogram with mask} |
     65|             TestType: Positive                                                   |
     66\----------------------------------------------------------------------------------/
     67
     68Bin number 0 bounds: (20.000000 - 21.000000) data (1000)
     69Bin number 1 bounds: (21.000000 - 22.000000) data (1000)
     70Bin number 2 bounds: (22.000000 - 23.000000) data (1000)
     71Bin number 3 bounds: (23.000000 - 24.000000) data (1000)
     72Bin number 4 bounds: (24.000000 - 25.000000) data (1000)
     73Bin number 5 bounds: (25.000000 - 26.000000) data (0)
     74Bin number 6 bounds: (26.000000 - 27.000000) data (0)
     75Bin number 7 bounds: (27.000000 - 28.000000) data (0)
     76Bin number 8 bounds: (28.000000 - 29.000000) data (0)
     77Bin number 9 bounds: (29.000000 - 30.000000) data (0)
     78
     79---> TESTPOINT PASSED (psStats functions{Allocate and Perform Histogram with mask} | tst_psHist02.c)
     80
    181/----------------------------- TESTPOINT ------------------------------------------\
    282|             TestFile: tst_psHist02.c                                             |
    … …  
    59139/----------------------------- TESTPOINT ------------------------------------------\
    60140|             TestFile: tst_psHist02.c                                             |
     141|            TestPoint: psStats functions{Calling psHistogramVector() with various NULL inputs.} |
     142|             TestType: Positive                                                   |
     143\----------------------------------------------------------------------------------/
     144
     145
     146---> TESTPOINT PASSED (psStats functions{Calling psHistogramVector() with various NULL inputs.} | tst_psHist02.c)
     147
     148/----------------------------- TESTPOINT ------------------------------------------\
     149|             TestFile: tst_psHist02.c                                             |
    61150|            TestPoint: psStats functions{Deallocate the psHistogram structure.}   |
    62151|             TestType: Positive                                                   |

  • trunk/psLib/test/sysUtils/tst_psTrace02.c

    r883 r893  
    1212{
    1313    FILE *fp;
     14    int nb = 0;
    1415
    15     printPositiveTestHeader(stdout,
    16                             "psTrace functions",
    17                             "psTrace()");
     16    fp = fopen("tst_psTrace02_OUT", "w");
     17    for (nb = 0 ; nb<4;nb++) {
     18        if (nb == 0)
     19            psTraceSetDestination(stdout);
     20        if (nb == 1)
     21            psTraceSetDestination(stderr);
     22        if (nb == 2)
     23            psTraceSetDestination(NULL);
     24        if (nb == 3)
     25            psTraceSetDestination(fp);
    1826
    19     psSetTraceLevel(".", 4);
    20     psTrace(".", 5, "(0) This message should not be displayed (%x)\n",
    21             0xbeefface);
    22     psSetTraceLevel(".", 7);
    23     psTrace(".", 5, "(0) This message should be displayed (%x)\n",
    24             0xbeefface);
     27        printPositiveTestHeader(stdout,
     28                                "psTrace functions",
     29                                "psTrace()");
    2530
    26     psSetTraceLevel(".a", 4);
    27     psTrace(".a", 5, "(1) This message should not be displayed (%x)\n",
    28             0xbeefface);
    29     psSetTraceLevel(".a", 7);
    30     psTrace(".a", 5, "(1) This message should be displayed (%x)\n",
    31             0xbeefface);
     31        psSetTraceLevel(".", 4);
     32        psTrace(".", 5, "(0) This message should not be displayed (%x)\n",
     33                0xbeefface);
     34        psSetTraceLevel(".", 7);
     35        psTrace(".", 5, "(0) This message should be displayed (%x)\n",
     36                0xbeefface);
     37
     38        psSetTraceLevel(".a", 4);
     39        psTrace(".a", 5, "(1) This message should not be displayed (%x)\n",
     40                0xbeefface);
     41        psSetTraceLevel(".a", 7);
     42        psTrace(".a", 5, "(1) This message should be displayed (%x)\n",
     43                0xbeefface);
    3244
    3345
    34     psSetTraceLevel(".a.b", 4);
    35     psTrace(".a.b", 5, "(2) This message should not be displayed (%x)\n",
    36             0xbeefface);
    37     psSetTraceLevel(".a.b", 7);
    38     psTrace(".a.b", 5, "(2) This message should be displayed (%x)\n",
    39             0xbeefface);
     46        psSetTraceLevel(".a.b", 4);
     47        psTrace(".a.b", 5, "(2) This message should not be displayed (%x)\n",
     48                0xbeefface);
     49        psSetTraceLevel(".a.b", 7);
     50        psTrace(".a.b", 5, "(2) This message should be displayed (%x)\n",
     51                0xbeefface);
    4052
    41     printFooter(stdout,
    42                 "psTrace functions",
    43                 "psTrace()",
    44                 true);
    45 
    46 
    47     fp = fopen("tst_psTrace02_OUT", "w");
    48     psTraceSetDestination(fp);
    49     psTrace(".", 5, "(0) This message should be displayed (%x)\n",
    50             0xbeefface);
     53        printFooter(stdout,
     54                    "psTrace functions",
     55                    "psTrace()",
     56                    true);
     57    }
    5158    fclose(fp);
    5259

  • trunk/psLib/test/sysUtils/verified/tst_psTrace02.stderr

    r554 r893  
     1     (0) This message should be displayed (beefface)
     2     (1) This message should be displayed (beefface)
     3     (2) This message should be displayed (beefface)

  • trunk/psLib/test/sysUtils/verified/tst_psTrace02.stdout

    r589 r893  
    1111---> TESTPOINT PASSED (psTrace functions{psTrace()} | tst_psTrace02.c)
    1212
     13/----------------------------- TESTPOINT ------------------------------------------\
     14|             TestFile: tst_psTrace02.c                                            |
     15|            TestPoint: psTrace functions{psTrace()}                               |
     16|             TestType: Positive                                                   |
     17\----------------------------------------------------------------------------------/
     18
     19
     20---> TESTPOINT PASSED (psTrace functions{psTrace()} | tst_psTrace02.c)
     21
     22/----------------------------- TESTPOINT ------------------------------------------\
     23|             TestFile: tst_psTrace02.c                                            |
     24|            TestPoint: psTrace functions{psTrace()}                               |
     25|             TestType: Positive                                                   |
     26\----------------------------------------------------------------------------------/
     27
     28     (0) This message should be displayed (beefface)
     29     (1) This message should be displayed (beefface)
     30     (2) This message should be displayed (beefface)
     31
     32---> TESTPOINT PASSED (psTrace functions{psTrace()} | tst_psTrace02.c)
     33
     34/----------------------------- TESTPOINT ------------------------------------------\
     35|             TestFile: tst_psTrace02.c                                            |
     36|            TestPoint: psTrace functions{psTrace()}                               |
     37|             TestType: Positive                                                   |
     38\----------------------------------------------------------------------------------/
     39
     40
     41---> TESTPOINT PASSED (psTrace functions{psTrace()} | tst_psTrace02.c)
     42
Note: See TracChangeset for help on using the changeset viewer.