Index: trunk/psLib/test/collections/tst_psArray.c
===================================================================
--- trunk/psLib/test/collections/tst_psArray.c	(revision 3281)
+++ trunk/psLib/test/collections/tst_psArray.c	(revision 3286)
@@ -17,6 +17,6 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.11 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2005-02-18 00:01:39 $
+ *  @version $Revision: 1.12 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2005-02-18 22:17:20 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -75,5 +75,5 @@
 
     // Test A - Create void pointer array
-    printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
+    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
     psArray *psArr = psArrayAlloc(5);
     if (psArr->nalloc != 5) {
@@ -81,9 +81,9 @@
         return 1;
     }
-    printFooter(stdout, "psArray", "Create void pointer array", true);
+    printFooter(stderr, "psArray", "Create void pointer array", true);
 
 
     // Test B - Add data to void pointer array
-    printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
+    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
     for(psS32 i = 0; i < 5; i++) {
         testStruct *ts = psAlloc(sizeof(testStruct));
@@ -97,5 +97,5 @@
     for(psS32 i = 0; i < 5; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
@@ -103,21 +103,21 @@
         }
     }
-    printf("array size = %d\n", psArr->nalloc);
+    fprintf(stderr,"array size = %d\n", psArr->nalloc);
     if (psArr->nalloc != 5) {
         psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
         return 3;
     }
-    printf("array population = %d\n", psArr->n);
+    fprintf(stderr,"array population = %d\n", psArr->n);
     if (psArr->n != 5) {
         psError(PS_ERR_UNKNOWN, true,"Array population wrong");
         return 4;
     }
-    printFooter(stdout, "psArray", "Add data to void pointer array", true);
+    printFooter(stderr, "psArray", "Add data to void pointer array", true);
 
 
     // Test C - Reallocate void pointer array bigger
-    printPositiveTestHeader(stdout,"psArray", "Reallocate void pointer array bigger");
+    printPositiveTestHeader(stderr,"psArray", "Reallocate void pointer array bigger");
     psArr = psArrayRealloc(psArr,10);
-    printf("Adding more elements to void pointer array...\n");
+    fprintf(stderr,"Adding more elements to void pointer array...\n");
     for(psS32 i = 5; i < 10; i++) {
         testStruct *ts = psAlloc(sizeof(testStruct));
@@ -131,5 +131,5 @@
     for(psS32 i = 0; i < 10; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
@@ -137,22 +137,22 @@
         }
     }
-    printf("array size = %d\n", psArr->nalloc);
+    fprintf(stderr,"array size = %d\n", psArr->nalloc);
     if (psArr->nalloc != 10) {
         psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
         return 6;
     }
-    printf("array population = %d\n", psArr->n);
+    fprintf(stderr,"array population = %d\n", psArr->n);
     if (psArr->n != 10) {
         psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
         return 7;
     }
-    printFooter(stdout, "psArray", "Reallocate void pointer array bigger", true);
+    printFooter(stderr, "psArray", "Reallocate void pointer array bigger", true);
 
     // Test D - Reallocate void pointer array smaller
-    printPositiveTestHeader(stdout,"psArray","Reallocate void pointer array smaller");
+    printPositiveTestHeader(stderr,"psArray","Reallocate void pointer array smaller");
     psArr = psArrayRealloc(psArr,3);
     for(psS32 i = 0; i < 3; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if (fabsf(ts->x - 10*i) > 0.01f || fabsf(ts->y - 10.1*i) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
@@ -160,34 +160,34 @@
         }
     }
-    printf("array size = %d\n", psArr->nalloc);
+    fprintf(stderr,"array size = %d\n", psArr->nalloc);
     if (psArr->nalloc != 3) {
         psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
         return 9;
     }
-    printf("array population = %d\n", psArr->n);
+    fprintf(stderr,"array population = %d\n", psArr->n);
     if (psArr->n != 3) {
         psError(PS_ERR_UNKNOWN, true,"Array Population wrong");
         return 10;
     }
-    printFooter(stdout, "psArray", "Reallocate integer void pointer smaller", true);
+    printFooter(stderr, "psArray", "Reallocate integer void pointer smaller", true);
 
     // Test E - Reallocate with a null
-    printNegativeTestHeader(stdout,"psArray","Reallocate with a null array",
+    printNegativeTestHeader(stderr,"psArray","Reallocate with a null array",
                             "Error message generator", 0 );
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     psArr1 = psArrayRealloc(NULL,5);
     if ( psArr1 != NULL ) {
-        printf("ERROR: Return is not NULL\n");
-    }
-    printFooter(stdout,"psArray","Reallocate with a null array",true);
+        fprintf(stderr,"ERROR: Return is not NULL\n");
+    }
+    printFooter(stderr,"psArray","Reallocate with a null array",true);
 
 
     // Test F - Remove item from array
-    printPositiveTestHeader(stdout, "psArray", "Remove valid item");
+    printPositiveTestHeader(stderr, "psArray", "Remove valid item");
     if( !psArrayRemove(psArr,mySt[0]) ) {
         psError(PS_ERR_UNKNOWN,true,"Unable to remove valid item");
         return 100;
     }
-    printf("Array size after removal = %d\n",psArr->n);
+    fprintf(stderr,"Array size after removal = %d\n",psArr->n);
     if ( psArr->n != 2 ) {
         psError(PS_ERR_UNKNOWN, true, "Items in array not decremented after removal");
@@ -196,5 +196,5 @@
     for(psS32 i = 0; i < psArr->n; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if(fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true, "Elements not as expected after remove.");
@@ -203,37 +203,37 @@
     }
     psFree(mySt[0]);
-    printFooter(stdout,"psArray","Remove valid item", true);
+    printFooter(stderr,"psArray","Remove valid item", true);
 
     // Test G - Remove invalid item from array
-    printPositiveTestHeader(stdout, "psArray", "Remove invalid item from array");
+    printPositiveTestHeader(stderr, "psArray", "Remove invalid item from array");
     if( psArrayRemove(psArr,mySt[9]) ) {
         psError(PS_ERR_UNKNOWN,true,"Removed invalid item from array");
         return 103;
     }
-    printFooter(stdout,"psArray","Remove invalid item from array",true);
+    printFooter(stderr,"psArray","Remove invalid item from array",true);
 
     // Test H - Remove item from null array
-    printPositiveTestHeader(stdout, "psArray", "Remove item from null array");
+    printPositiveTestHeader(stderr, "psArray", "Remove item from null array");
     if ( psArrayRemove(NULL,mySt[1]) ) {
         psError(PS_ERR_UNKNOWN,true,"Removed valid item from null array");
         return 104;
     }
-    printFooter(stdout,"psArray","Remove item from null array",true);
+    printFooter(stderr,"psArray","Remove item from null array",true);
 
     // Test I - Remove null item from array
-    printPositiveTestHeader(stdout, "psArray", "Remove null item from array");
+    printPositiveTestHeader(stderr, "psArray", "Remove null item from array");
     if( psArrayRemove(psArr,NULL) ) {
         psError(PS_ERR_UNKNOWN,true,"Remove null item from array",true);
         return 105;
     }
-    printFooter(stdout,"psArray","Remove null item from array",true);
+    printFooter(stderr,"psArray","Remove null item from array",true);
 
     // Test J - Free void pointer array
-    printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
+    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
     psFree(psArr);
     for(psS32 i = 0; i < 10; i++) {
         psFree(mySt[i]);
     }
-    if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
+    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
         psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
         return 110;
@@ -241,8 +241,8 @@
     psS32 nBad = psMemCheckCorruption(0);
     if(nBad) {
-        printf("ERROR: Found %d bad memory blocks\n", nBad);
+        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
         return 111;
     }
-    printFooter(stdout, "psArray" ,"Free void pointer array", true);
+    printFooter(stderr, "psArray" ,"Free void pointer array", true);
 
     return 0;
@@ -255,5 +255,5 @@
 
     // Test A - Create void pointer array
-    printPositiveTestHeader(stdout,"psArray", "Create void pointer array");
+    printPositiveTestHeader(stderr,"psArray", "Create void pointer array");
     psArray *psArr = psArrayAlloc(10);
     if (psArr->nalloc != 10) {
@@ -261,8 +261,8 @@
         return 1;
     }
-    printFooter(stdout, "psArray", "Create void pointer array", true);
+    printFooter(stderr, "psArray", "Create void pointer array", true);
 
     // Test B - Add data to void pointer array
-    printPositiveTestHeader(stdout, "psArray", "Add data to void pointer array");
+    printPositiveTestHeader(stderr, "psArray", "Add data to void pointer array");
     for(psS32 i = 0; i < 10; i++) {
         testStruct *ts = psAlloc(sizeof(testStruct));
@@ -276,5 +276,5 @@
     for(psS32 i = 0; i < 10; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if (fabsf(ts->x - 10*(10-i)) > 0.01f || fabsf(ts->y - 10.1*(10-i)) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
@@ -282,22 +282,22 @@
         }
     }
-    printf("array size = %d\n", psArr->nalloc);
+    fprintf(stderr,"array size = %d\n", psArr->nalloc);
     if (psArr->nalloc != 10) {
         psError(PS_ERR_UNKNOWN, true,"Array Size wrong");
         return 3;
     }
-    printf("array population = %d\n", psArr->n);
+    fprintf(stderr,"array population = %d\n", psArr->n);
     if (psArr->n != 10) {
         psError(PS_ERR_UNKNOWN, true,"Array population wrong");
         return 4;
     }
-    printFooter(stdout, "psArray", "Add data to void pointer array", true);
+    printFooter(stderr, "psArray", "Add data to void pointer array", true);
 
     // Test C - Sort data in array
-    printPositiveTestHeader(stdout,"psArray","Sort data in array");
+    printPositiveTestHeader(stderr,"psArray","Sort data in array");
     psArr = psArraySort(psArr,testStructCompare);
     for(psS32 i = 0; i < 10; i++) {
         testStruct *ts = (testStruct*)psArr->data[i];
-        printf("ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
+        fprintf(stderr,"ts[%d].x = %d ts[%d].y = %.2f\n", i, ts->x, i, ts->y);
         if (fabsf(ts->x - 10*(i+1)) > 0.01f || fabsf(ts->y - 10.1*(i+1)) > 0.01f) {
             psError(PS_ERR_UNKNOWN, true,"Couldn't properly get elements from array.");
@@ -305,8 +305,8 @@
         }
     }
-    printFooter(stdout,"psArray","Sort data in array",true);
+    printFooter(stderr,"psArray","Sort data in array",true);
 
     // Test D - Attempt to sort null array
-    printPositiveTestHeader(stdout,"psArray","Attempt to sort array");
+    printPositiveTestHeader(stderr,"psArray","Attempt to sort array");
     psArray* tempArr = psArraySort(NULL,testStructCompare);
     if(tempArr != NULL) {
@@ -314,13 +314,13 @@
         return 6;
     }
-    printFooter(stdout,"psArray","Attempt to sort array",true);
+    printFooter(stderr,"psArray","Attempt to sort array",true);
 
     // Test E - Free void pointer array
-    printPositiveTestHeader(stdout, "psArray", "Free void pointer array");
+    printPositiveTestHeader(stderr, "psArray", "Free void pointer array");
     psFree(psArr);
     for(psS32 i = 0; i < 10; i++) {
         psFree(mySt[i]);
     }
-    if( psMemCheckLeaks(0, NULL, stdout, false) != 0) {
+    if( psMemCheckLeaks(0, NULL, stderr, false) != 0) {
         psError(PS_ERR_UNKNOWN,true,"Memory leaks detected.");
         return 110;
@@ -328,8 +328,8 @@
     psS32 nBad = psMemCheckCorruption(0);
     if(nBad) {
-        printf("ERROR: Found %d bad memory blocks\n", nBad);
+        fprintf(stderr,"ERROR: Found %d bad memory blocks\n", nBad);
         return 111;
     }
-    printFooter(stdout, "psArray" ,"Free void pointer array", true);
+    printFooter(stderr, "psArray" ,"Free void pointer array", true);
 
     return 0;
@@ -352,4 +352,14 @@
         data = psAlloc(sizeof(float));
         arr = psArrayAdd(arr, delta*2, data); // make delta unique versus next delta used.
+
+        subtest++;
+        if (psMemGetRefCounter(data) != 2) {
+            // in response of Bug #302
+            psError(PS_ERR_UNKNOWN, true,
+                    "psArrayAdd did not increment the data reference count.");
+            return subtest;
+        }
+
+        psFree(data);
 
         subtest++;
@@ -381,4 +391,5 @@
     data = psAlloc(sizeof(float));
     arr = psArrayAdd(arr, delta, data);
+    psFree(data);
 
     // make sure the array was expanded
@@ -411,4 +422,5 @@
         data = psAlloc(sizeof(float));
         arr = psArrayAdd(arr, 0, data);
+        psFree(data);
     }
     nalloc = arr->nalloc;
@@ -419,4 +431,5 @@
     data = psAlloc(sizeof(float));
     arr = psArrayAdd(arr, 0, data);
+    psFree(data);
 
     subtest++;