Changeset 887 for trunk/psLib/test/dataManip/tst_psStats02.c

Timestamp:

Jun 6, 2004, 2:31:55 PM (22 years ago)

Author:

gusciora

Message:

Most of these tests work.

File:

• trunk/psLib/test/dataManip/tst_psStats02.c (modified) (2 diffs)

trunk/psLib/test/dataManip/tst_psStats02.c

@@ -1 +1 @@
 /*****************************************************************************
     This routine must ensure that PS_STAT_MIN is correctly computed
-    by the procedure psArrayStats().
+    by the procedure psVectorStats().
  *****************************************************************************/
 #include <stdio.h>
@@ -11 +11 @@
 {
     psStats *myStats    = NULL;
-    psStats *myStats2   = NULL;
     int testStatus      = true;
+    int globalTestStatus = true;
     int i               = 0;
     psVector *myVector  = NULL;
     psVector *maskVector= NULL;
     float min           = 1e99;
-    float realMin1      = 1e99;
-    float realMin2      = 1e99;
+    float realMinNoMask   = 1e99;
+    float realMinWithMask = 1e99;
+    int currentId       = psMemGetId();
+    int memLeaks        = 0;
 
-    printPositiveTestHeader(stdout,
-                            "psStats functions",
-                            "PS_STAT_MIN");
-
+    /*************************************************************************/
+    /*  Allocate and initialize data structures                      */
+    /*************************************************************************/
     myStats = psStatsAlloc(PS_STAT_MIN);
-    myVector = psVectorAlloc(PS_TYPE_FLOAT, N);
+    myVector = psVectorAlloc(N, PS_TYPE_F32);
     myVector->n = N;
-    maskVector = psVectorAlloc(PS_TYPE_UINT8, N);
+    maskVector = psVectorAlloc(N, PS_TYPE_U8);
     maskVector->n = N;
 
+    // Set the appropriate values for the vector data.
     for (i=0;i<N;i++) {
-        myVector->vec.f[i] = (float) i;
+        myVector->data.F32[i] = (float) i;
+    }
+
+    // Set the mask vector and calculate the expected minimum.
+    for (i=0;i<N;i++) {
+        if (myVector->data.F32[i] < realMinNoMask) {
+            realMinNoMask = myVector->data.F32[i];
+        }
+
         if (i < (N/2)) {
-            maskVector->vec.ui8[i] = 0;
-            if (myVector->vec.f[i] < realMin2) {
-                realMin2 = myVector->vec.f[i];
-            }
+            maskVector->data.U8[i] = 1;
         } else {
-            printf("Masking element %d\n", i);
-            maskVector->vec.ui8[i] = 1;
-            if (myVector->vec.f[i] < realMin1) {
-                realMin1 = myVector->vec.f[i];
+            maskVector->data.U8[i] = 0;
+            if (myVector->data.F32[i] < realMinWithMask) {
+                realMinWithMask = myVector->data.F32[i];
             }
         }
     }
 
-    myStats2 = psArrayStats(myVector, NULL, 0, myStats);
-    min = myStats2->min;
+    /*************************************************************************/
+    /*  Call psVectorStats() with no vector mask.                    */
+    /*************************************************************************/
+    printPositiveTestHeader(stdout,
+                            "psStats functions",
+                            "PS_STAT_MIN: no vector mask");
 
-    printf("Called psArrayStats() on a vector with no elements masked.\n");
-    printf("The expected min was %f; the calculated min was %f\n", realMin1, min);
-    if (min == realMin1) {
+    myStats = psVectorStats(myStats, myVector, NULL, 0);
+    min = myStats->min;
+
+    printf("Called psVectorStats() on a vector with no elements masked.\n");
+    printf("The expected min was %f; the calculated min was %f\n",
+           realMinNoMask, min);
+    if (min == realMinNoMask) {
         testStatus = true;
     } else {
         testStatus = false;
+        globalTestStatus = false;
     }
+    printFooter(stdout,
+                "psVector functions",
+                "PS_STAT_MIN: no vector mask",
+                testStatus);
 
-    myStats2 = psArrayStats(myVector, maskVector, 1, myStats);
-    min = myStats2->min;
-    printf("Called psArrayStats() on a vector with last N/2 elements masked.\n");
-    printf("The expected min was %f; the calculated min was %f\n", realMin2, min);
-    if (min == realMin2) {
+    /*************************************************************************/
+    /*  Call psVectorStats() with vector mask.                       */
+    /*************************************************************************/
+    printPositiveTestHeader(stdout,
+                            "psStats functions",
+                            "PS_STAT_MIN: with vector mask");
+
+    myStats = psVectorStats(myStats, myVector, maskVector, 1);
+    min = myStats->min;
+    printf("Called psVectorStats() on a vector with last N/2 elements masked.\n");
+    printf("The expected min was %f; the calculated min was %f\n",
+           realMinWithMask, min);
+    if (min == realMinWithMask) {
         testStatus = true;
     } else {
         testStatus = false;
+        globalTestStatus = false;
     }
 
     printFooter(stdout,
-                "psHash functions",
-                "psHashAlloc()",
+                "psVector functions",
+                "PS_STAT_MIN: with vector mask",
                 testStatus);
 
-    return (!testStatus);
+    /*************************************************************************/
+    /*  Deallocate data structures                                   */
+    /*************************************************************************/
+    printPositiveTestHeader(stdout,
+                            "psStats functions",
+                            "psStats(): deallocating memory");
+
+    psStatsFree(myStats);
+    psVectorFree(myVector);
+    psVectorFree(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);
 }