Index: trunk/psLib/test/sysUtils/tst_psString.c
===================================================================
--- trunk/psLib/test/sysUtils/tst_psString.c	(revision 1703)
+++ trunk/psLib/test/sysUtils/tst_psString.c	(revision 1714)
@@ -17,6 +17,6 @@
  *  @author  Eric Van Alst, MHPCC
  *
- *  @version $Revision: 1.7 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2004-08-06 22:34:06 $
+ *  @version $Revision: 1.8 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2004-09-08 00:09:36 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -28,4 +28,31 @@
 #include "psTest.h"
 
+static int testStringCopy00(void);
+static int testStringCopy01(void);
+static int testStringCopy02(void);
+static int testStringCopy03(void);
+static int testStringCopy04(void);
+static int testStringCopy05(void);
+static int testStringCopy06(void);
+
+testDescription tests[] = {
+                              {testStringCopy00, 0, "Verify string copy", 0, false},
+                              {testStringCopy01, 1, "Verify empty string copy", 0, false},
+                              {testStringCopy02, 2, "Verify string copy with length", 0, false},
+                              {testStringCopy03, 3, "Verify empty string copy with length", 0, false},
+                              {testStringCopy04, 4, "Copy string to larger string", 0, false},
+                              {testStringCopy05, 5, "Copy string with negative size", 0, false},
+                              {testStringCopy06, 6, "Verify creation of string literal", 0, false},
+                              {NULL}
+                          };
+
+int main( int argc, char* argv[] )
+{
+    psLogSetLevel( PS_LOG_INFO );
+
+    return ( ! runTestSuite( stderr, "psString", tests, argc, argv ) );
+}
+
+/*
 int main( int argc,
           char * argv[] )
@@ -46,7 +73,15 @@
     int   memBlockAllocated = 0;
     psMemBlock ***memBlockPtr = NULL;
+ 
+*/
+
+static int testStringCopy00(void)
+{
+    char  stringval[20] = "E R R O R";
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
 
     // Test point #1 Verify string copy - psStringCopy
-    printPositiveTestHeader(stderr,"psStringCopy","Verify string copy");
     strResult = psStringCopy(stringval);
     // Perform string compare
@@ -63,15 +98,20 @@
         fprintf(stderr, "             changed           src = %s expected %s\n",strResult,
                 stringval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
-    }
+        return 1;
+    }
+
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringCopy","Verify string copy", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy01(void)
+{
+    char  *emptyval = "";
+    int   result = 0;
+    char  *strResult;
 
     // Test point #2 Verify empty string copy - psStringCopy
-    printPositiveTestHeader(stderr,"psStringCopy","Verify empty string copy");
     strResult = psStringCopy(emptyval);
     // Perform string compare
@@ -81,15 +121,23 @@
         fprintf(stderr,"                               src = %s expected %s\n",
                 strResult, emptyval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
-    }
+        return 1;
+    }
+
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringCopy","Verify empty string copy", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy02(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  stringval1[20] = "e r r o r";
+    int   substringlen = 6;
+    char  *substringval = "e r r";
 
     // Test point #3 Verify string copy with length - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy","Verify string copy with length");
     strResult = psStringNCopy(stringval1, substringlen);
     // Perform string compare and get string length
@@ -105,15 +153,20 @@
         fprintf(stderr,"                               src = %s expected %s\n",
                 strResult, substringval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy","Verify string copy with length", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy03(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  *stringvalnocopy = "F A I L";
 
     // Test point #4 Verify empty string copy with length - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Verify empty string copy with length");
     strResult = psStringNCopy(stringvalnocopy, 0);
     // Perform string compare and get sting length
@@ -124,15 +177,21 @@
         fprintf(stderr,"                               src = %s didn't expected %s\n",
                 strResult, stringvalnocopy);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy","Verify empty string copy with length", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy04(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   increaseSize = 5;
 
     // Test point #5 Copy string to larger string - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Copy string to larger string");
     strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize));
     // Perform string compare and get string length
@@ -147,57 +206,45 @@
         fprintf(stderr,"                     strlne result = %d expected %d\n",result1,
                 (int)strlen(stringval));
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy", "Copy string to larger string", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy05(void)
+{
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   negativeSize = -5;
 
     // Test point #6 Copy string with negative size - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Copy string with negative size");
     strResult = psStringNCopy(stringval, negativeSize);
     if ( strResult != NULL ) {
         fprintf(stderr,"Failed test point #6 return value = %ld expected NULL\n",
                 (unsigned long)strResult);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Memory should not have been allocated
-    printFooter(stderr, "psStringNCopy", "Copy string with negative size", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy06(void)
+{
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   result = 0;
 
     // Test point #7 Verify creation of string literal - PS_STRING
-    printPositiveTestHeader(stderr,"PS_STRING","Verify creation of string literal");
     strResult = PS_STRING(E R R O R);
     result = strcmp(strResult, stringval);
     if ( result != 0 ) {
         fprintf(stderr,"Failed test point #7 strcmp result = %d expected %d",result,0);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Memory should not have been allocated
-    printFooter(stderr, "PS_STRING", "Verify creation of string literal", tpResult);
-
-    // Check for memory leaks
-    memBlockAllocated = psMemCheckLeaks(0, memBlockPtr, stderr);
-    if ( memBlockAllocated != 0 ) {
-        fprintf(stderr,"Failed - Memory leaks detected - Blocks still allocated = %d\n",
-                memBlockAllocated);
-        tpFails++;
-    }
-
-    // Display test driver fail message if tpFail not zero
-    if ( tpFails != 0 ) {
-        fprintf(stderr,"Failed test driver  testpoint fail = %d expected %d\n",
-                tpFails, 0);
-    }
-
-    // Return number of test points which failed
-    return tpFails;
-}
-
+
+    return 0;
+}
Index: trunk/psLib/test/sysUtils/tst_psStringCopy.c
===================================================================
--- trunk/psLib/test/sysUtils/tst_psStringCopy.c	(revision 1703)
+++ trunk/psLib/test/sysUtils/tst_psStringCopy.c	(revision 1714)
@@ -17,6 +17,6 @@
  *  @author  Eric Van Alst, MHPCC
  *
- *  @version $Revision: 1.7 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2004-08-06 22:34:06 $
+ *  @version $Revision: 1.8 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2004-09-08 00:09:36 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -28,4 +28,31 @@
 #include "psTest.h"
 
+static int testStringCopy00(void);
+static int testStringCopy01(void);
+static int testStringCopy02(void);
+static int testStringCopy03(void);
+static int testStringCopy04(void);
+static int testStringCopy05(void);
+static int testStringCopy06(void);
+
+testDescription tests[] = {
+                              {testStringCopy00, 0, "Verify string copy", 0, false},
+                              {testStringCopy01, 1, "Verify empty string copy", 0, false},
+                              {testStringCopy02, 2, "Verify string copy with length", 0, false},
+                              {testStringCopy03, 3, "Verify empty string copy with length", 0, false},
+                              {testStringCopy04, 4, "Copy string to larger string", 0, false},
+                              {testStringCopy05, 5, "Copy string with negative size", 0, false},
+                              {testStringCopy06, 6, "Verify creation of string literal", 0, false},
+                              {NULL}
+                          };
+
+int main( int argc, char* argv[] )
+{
+    psLogSetLevel( PS_LOG_INFO );
+
+    return ( ! runTestSuite( stderr, "psString", tests, argc, argv ) );
+}
+
+/*
 int main( int argc,
           char * argv[] )
@@ -46,7 +73,15 @@
     int   memBlockAllocated = 0;
     psMemBlock ***memBlockPtr = NULL;
+ 
+*/
+
+static int testStringCopy00(void)
+{
+    char  stringval[20] = "E R R O R";
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
 
     // Test point #1 Verify string copy - psStringCopy
-    printPositiveTestHeader(stderr,"psStringCopy","Verify string copy");
     strResult = psStringCopy(stringval);
     // Perform string compare
@@ -63,15 +98,20 @@
         fprintf(stderr, "             changed           src = %s expected %s\n",strResult,
                 stringval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
-    }
+        return 1;
+    }
+
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringCopy","Verify string copy", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy01(void)
+{
+    char  *emptyval = "";
+    int   result = 0;
+    char  *strResult;
 
     // Test point #2 Verify empty string copy - psStringCopy
-    printPositiveTestHeader(stderr,"psStringCopy","Verify empty string copy");
     strResult = psStringCopy(emptyval);
     // Perform string compare
@@ -81,15 +121,23 @@
         fprintf(stderr,"                               src = %s expected %s\n",
                 strResult, emptyval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
-    }
+        return 1;
+    }
+
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringCopy","Verify empty string copy", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy02(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  stringval1[20] = "e r r o r";
+    int   substringlen = 6;
+    char  *substringval = "e r r";
 
     // Test point #3 Verify string copy with length - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy","Verify string copy with length");
     strResult = psStringNCopy(stringval1, substringlen);
     // Perform string compare and get string length
@@ -105,15 +153,20 @@
         fprintf(stderr,"                               src = %s expected %s\n",
                 strResult, substringval);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory allocated
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy","Verify string copy with length", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy03(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  *stringvalnocopy = "F A I L";
 
     // Test point #4 Verify empty string copy with length - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Verify empty string copy with length");
     strResult = psStringNCopy(stringvalnocopy, 0);
     // Perform string compare and get sting length
@@ -124,15 +177,21 @@
         fprintf(stderr,"                               src = %s didn't expected %s\n",
                 strResult, stringvalnocopy);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy","Verify empty string copy with length", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy04(void)
+{
+    int   result = 0;
+    int   result1 = 0;
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   increaseSize = 5;
 
     // Test point #5 Copy string to larger string - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Copy string to larger string");
     strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize));
     // Perform string compare and get string length
@@ -147,57 +206,45 @@
         fprintf(stderr,"                     strlne result = %d expected %d\n",result1,
                 (int)strlen(stringval));
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Free memory
     psFree(strResult);
-    printFooter(stderr, "psStringNCopy", "Copy string to larger string", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy05(void)
+{
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   negativeSize = -5;
 
     // Test point #6 Copy string with negative size - psStringNCopy
-    printPositiveTestHeader(stderr,"psStringNCopy", "Copy string with negative size");
     strResult = psStringNCopy(stringval, negativeSize);
     if ( strResult != NULL ) {
         fprintf(stderr,"Failed test point #6 return value = %ld expected NULL\n",
                 (unsigned long)strResult);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Memory should not have been allocated
-    printFooter(stderr, "psStringNCopy", "Copy string with negative size", tpResult);
+
+    return 0;
+}
+
+static int testStringCopy06(void)
+{
+    char  *strResult;
+    char  stringval[20] = "E R R O R";
+    int   result = 0;
 
     // Test point #7 Verify creation of string literal - PS_STRING
-    printPositiveTestHeader(stderr,"PS_STRING","Verify creation of string literal");
     strResult = PS_STRING(E R R O R);
     result = strcmp(strResult, stringval);
     if ( result != 0 ) {
         fprintf(stderr,"Failed test point #7 strcmp result = %d expected %d",result,0);
-        tpResult = false;
-        tpFails++;
-    } else {
-        tpResult = true;
+        return 1;
     }
     // Memory should not have been allocated
-    printFooter(stderr, "PS_STRING", "Verify creation of string literal", tpResult);
-
-    // Check for memory leaks
-    memBlockAllocated = psMemCheckLeaks(0, memBlockPtr, stderr);
-    if ( memBlockAllocated != 0 ) {
-        fprintf(stderr,"Failed - Memory leaks detected - Blocks still allocated = %d\n",
-                memBlockAllocated);
-        tpFails++;
-    }
-
-    // Display test driver fail message if tpFail not zero
-    if ( tpFails != 0 ) {
-        fprintf(stderr,"Failed test driver  testpoint fail = %d expected %d\n",
-                tpFails, 0);
-    }
-
-    // Return number of test points which failed
-    return tpFails;
-}
-
+
+    return 0;
+}
Index: trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr
===================================================================
--- trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr	(revision 1703)
+++ trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr	(revision 1714)
@@ -115,5 +115,5 @@
 <DATE><TIME>|<HOST>|I| TPmultipleFree|Next should be an error about multiple freeing.
 <DATE><TIME>|<HOST>|E|psLib.sysUtils.|Memory block 1 was freed but still used.
-<DATE><TIME>|<HOST>|E|psLib.sysUtils.|Block 1 allocated at tst_psMemory.c:<LINENO> freed more than once at tst_psMemory.c:<LINENO>
+<DATE><TIME>|<HOST>|E|psLib.sysUtils.|Block 1 allocated at tst_psMemory.c:<LINENO> freed more than once at tst_psMemory.c:<LINENO>.
 <DATE><TIME>|<HOST>|A|memProblemCallb|Detected a problem in the memory system at tst_psMemory.c:<LINENO>
 
Index: trunk/psLib/test/sysUtils/verified/tst_psStringCopy.stderr
===================================================================
--- trunk/psLib/test/sysUtils/verified/tst_psStringCopy.stderr	(revision 1703)
+++ trunk/psLib/test/sysUtils/verified/tst_psStringCopy.stderr	(revision 1714)
@@ -1,64 +1,64 @@
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringCopy{Verify string copy}                           *
+*            TestPoint: psString{Verify string copy}                               *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (psStringCopy{Verify string copy} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Verify string copy} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringCopy{Verify empty string copy}                     *
+*            TestPoint: psString{Verify empty string copy}                         *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (psStringCopy{Verify empty string copy} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Verify empty string copy} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringNCopy{Verify string copy with length}              *
+*            TestPoint: psString{Verify string copy with length}                   *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (psStringNCopy{Verify string copy with length} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Verify string copy with length} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringNCopy{Verify empty string copy with length}        *
+*            TestPoint: psString{Verify empty string copy with length}             *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (psStringNCopy{Verify empty string copy with length} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Verify empty string copy with length} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringNCopy{Copy string to larger string}                *
+*            TestPoint: psString{Copy string to larger string}                     *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (psStringNCopy{Copy string to larger string} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Copy string to larger string} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: psStringNCopy{Copy string with negative size}              *
+*            TestPoint: psString{Copy string with negative size}                   *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|E|     psString.c|psStringNCopy with negative count specified -5
+<DATE><TIME>|<HOST>|E|psLib.sysUtils.|Can not copy a negative number of characters (-5)
 
----> TESTPOINT PASSED (psStringNCopy{Copy string with negative size} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Copy string with negative size} | tst_psStringCopy.c)
 
 /***************************** TESTPOINT ******************************************\
 *             TestFile: tst_psStringCopy.c                                         *
-*            TestPoint: PS_STRING{Verify creation of string literal}               *
+*            TestPoint: psString{Verify creation of string literal}                *
 *             TestType: Positive                                                   *
 \**********************************************************************************/
 
 
----> TESTPOINT PASSED (PS_STRING{Verify creation of string literal} | tst_psStringCopy.c)
+---> TESTPOINT PASSED (psString{Verify creation of string literal} | tst_psStringCopy.c)