Index: trunk/psLib/test/collections/tst_psArray.c
===================================================================
--- trunk/psLib/test/collections/tst_psArray.c	(revision 3285)
+++ 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++;
Index: trunk/psLib/test/collections/verified/tst_psArray.stderr
===================================================================
--- trunk/psLib/test/collections/verified/tst_psArray.stderr	(revision 3285)
+++ trunk/psLib/test/collections/verified/tst_psArray.stderr	(revision 3286)
@@ -1,6 +1,220 @@
-<DATE><TIME>|<HOST>|I|main
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{psArray}                                           *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Create void pointer array}                         *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Add data to void pointer array}                    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+ts[0].x = 0 ts[0].y = 0.00
+ts[1].x = 10 ts[1].y = 10.10
+ts[2].x = 20 ts[2].y = 20.20
+ts[3].x = 30 ts[3].y = 30.30
+ts[4].x = 40 ts[4].y = 40.40
+array size = 5
+array population = 5
+
+---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Reallocate void pointer array bigger}              *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Adding more elements to void pointer array...
+ts[0].x = 0 ts[0].y = 0.00
+ts[1].x = 10 ts[1].y = 10.10
+ts[2].x = 20 ts[2].y = 20.20
+ts[3].x = 30 ts[3].y = 30.30
+ts[4].x = 40 ts[4].y = 40.40
+ts[5].x = 50 ts[5].y = 50.50
+ts[6].x = 60 ts[6].y = 60.60
+ts[7].x = 70 ts[7].y = 70.70
+ts[8].x = 80 ts[8].y = 80.80
+ts[9].x = 90 ts[9].y = 90.90
+array size = 10
+array population = 10
+
+---> TESTPOINT PASSED (psArray{Reallocate void pointer array bigger} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Reallocate void pointer array smaller}             *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+ts[0].x = 0 ts[0].y = 0.00
+ts[1].x = 10 ts[1].y = 10.10
+ts[2].x = 20 ts[2].y = 20.20
+array size = 3
+array population = 3
+
+---> TESTPOINT PASSED (psArray{Reallocate integer void pointer smaller} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Reallocate with a null array}                      *
+*             TestType: Negative                                                   *
+*    ExpectedErrorText: Error message generator                                    *
+*  ExpectedStatusValue: 0                                                          *
+\**********************************************************************************/
+
+<DATE><TIME>|<HOST>|I|testArray
     Following should generate an error message.
 <DATE><TIME>|<HOST>|E|psArrayRealloc (FILE:LINENO)
     psArrayRealloc must be given a non-NULL psArray to resize.
+
+---> TESTPOINT PASSED (psArray{Reallocate with a null array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Remove valid item}                                 *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+Array size after removal = 2
+ts[0].x = 10 ts[0].y = 10.10
+ts[1].x = 20 ts[1].y = 20.20
+
+---> TESTPOINT PASSED (psArray{Remove valid item} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Remove invalid item from array}                    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Remove invalid item from array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Remove item from null array}                       *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
 <DATE><TIME>|<HOST>|E|psArrayRemove (FILE:LINENO)
     Specified psArray can not be NULL.
+
+---> TESTPOINT PASSED (psArray{Remove item from null array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Remove null item from array}                       *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Remove null item from array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Free void pointer array}                           *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
+
+
+---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{psArray}                                           *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Create void pointer array}                         *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Add data to void pointer array}                    *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+ts[0].x = 100 ts[0].y = 101.00
+ts[1].x = 90 ts[1].y = 90.90
+ts[2].x = 80 ts[2].y = 80.80
+ts[3].x = 70 ts[3].y = 70.70
+ts[4].x = 60 ts[4].y = 60.60
+ts[5].x = 50 ts[5].y = 50.50
+ts[6].x = 40 ts[6].y = 40.40
+ts[7].x = 30 ts[7].y = 30.30
+ts[8].x = 20 ts[8].y = 20.20
+ts[9].x = 10 ts[9].y = 10.10
+array size = 10
+array population = 10
+
+---> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Sort data in array}                                *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+ts[0].x = 10 ts[0].y = 10.10
+ts[1].x = 20 ts[1].y = 20.20
+ts[2].x = 30 ts[2].y = 30.30
+ts[3].x = 40 ts[3].y = 40.40
+ts[4].x = 50 ts[4].y = 50.50
+ts[5].x = 60 ts[5].y = 60.60
+ts[6].x = 70 ts[6].y = 70.70
+ts[7].x = 80 ts[7].y = 80.80
+ts[8].x = 90 ts[8].y = 90.90
+ts[9].x = 100 ts[9].y = 101.00
+
+---> TESTPOINT PASSED (psArray{Sort data in array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Attempt to sort array}                             *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Attempt to sort array} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{Free void pointer array}                           *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
+
+
+---> TESTPOINT PASSED (psArray{psArray} | tst_psArray.c)
+
+/***************************** TESTPOINT ******************************************\
+*             TestFile: tst_psArray.c                                              *
+*            TestPoint: psArray{psArrayAdd}                                        *
+*             TestType: Positive                                                   *
+\**********************************************************************************/
+
+
+---> TESTPOINT PASSED (psArray{psArrayAdd} | tst_psArray.c)
+
Index: trunk/psLib/test/collections/verified/tst_psArray.stdout
===================================================================
--- trunk/psLib/test/collections/verified/tst_psArray.stdout	(revision 3285)
+++ 	(revision )
@@ -1,120 +1,0 @@
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Create void pointer array}                         *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Create void pointer array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Add data to void pointer array}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-ts[0].x = 0 ts[0].y = 0.00
-ts[1].x = 10 ts[1].y = 10.10
-ts[2].x = 20 ts[2].y = 20.20
-ts[3].x = 30 ts[3].y = 30.30
-ts[4].x = 40 ts[4].y = 40.40
-array size = 5
-array population = 5
-
----> TESTPOINT PASSED (psArray{Add data to void pointer array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Reallocate void pointer array bigger}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Adding more elements to void pointer array...
-ts[0].x = 0 ts[0].y = 0.00
-ts[1].x = 10 ts[1].y = 10.10
-ts[2].x = 20 ts[2].y = 20.20
-ts[3].x = 30 ts[3].y = 30.30
-ts[4].x = 40 ts[4].y = 40.40
-ts[5].x = 50 ts[5].y = 50.50
-ts[6].x = 60 ts[6].y = 60.60
-ts[7].x = 70 ts[7].y = 70.70
-ts[8].x = 80 ts[8].y = 80.80
-ts[9].x = 90 ts[9].y = 90.90
-array size = 10
-array population = 10
-
----> TESTPOINT PASSED (psArray{Reallocate void pointer array bigger} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Reallocate void pointer array smaller}             *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-ts[0].x = 0 ts[0].y = 0.00
-ts[1].x = 10 ts[1].y = 10.10
-ts[2].x = 20 ts[2].y = 20.20
-array size = 3
-array population = 3
-
----> TESTPOINT PASSED (psArray{Reallocate integer void pointer smaller} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Reallocate with a null array}                      *
-*             TestType: Negative                                                   *
-*    ExpectedErrorText: Error message generator                                    *
-*  ExpectedStatusValue: 0                                                          *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Reallocate with a null array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Remove valid item}                                 *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-Array size after removal = 2
-ts[0].x = 10 ts[0].y = 10.10
-ts[1].x = 20 ts[1].y = 20.20
-
----> TESTPOINT PASSED (psArray{Remove valid item} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Remove invalid item from array}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Remove invalid item from array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Remove item from null array}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Remove item from null array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Remove null item from array}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Remove null item from array} | tst_psArray.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psArray.c                                              *
-*            TestPoint: psArray{Free void pointer array}                           *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psArray{Free void pointer array} | tst_psArray.c)
-