Index: trunk/psLib/test/types/Makefile.am
===================================================================
--- trunk/psLib/test/types/Makefile.am	(revision 8797)
+++ trunk/psLib/test/types/Makefile.am	(revision 8805)
@@ -23,5 +23,6 @@
 	tap_psMetadata_manip   \
 	tap_psMetadata_polynomials \
-	tap_psArray_all
+	tap_psArray_all \
+	tap_psArguments_all
 
 check_DATA = \
Index: trunk/psLib/test/types/execute_tap
===================================================================
--- trunk/psLib/test/types/execute_tap	(revision 8797)
+++ trunk/psLib/test/types/execute_tap	(revision 8805)
@@ -11,2 +11,3 @@
 ./tap_psMetadata_printing
 ./tap_psMetadata_polynomials
+./tap_psArguments_all
Index: trunk/psLib/test/types/tap_psArguments_all.c
===================================================================
--- trunk/psLib/test/types/tap_psArguments_all.c	(revision 8805)
+++ trunk/psLib/test/types/tap_psArguments_all.c	(revision 8805)
@@ -0,0 +1,429 @@
+/**
+ *  C Implementation: tap_psArguments_all
+ *
+ * Description:  Tests for psArgumentVerbosity, psArgumentGet, psArgumentRemove,
+ *               psArgumentParse, psArgumentHelp, psLogArguments, psTraceArguments
+ *
+ *
+ * Author: dRob <David.Robbins@mhpcc.hpc.mil>, (C) 2006
+ *
+ * Copyright: See COPYING file that comes with this distribution
+ *
+ */
+
+#include <pslib.h>
+
+#include "tap.h"
+#include "pstap.h"
+
+void testArgumentGetParse(void);
+void testArgumentVerbosity(void);
+void testLogTraceArguments(void);
+
+int main(void)
+{
+    plan_tests(39);
+
+    diag("Tests for psArguments Functions");
+
+    testArgumentGetParse();
+    testArgumentVerbosity();
+    testLogTraceArguments();
+
+    done();
+}
+
+void testArgumentGetParse(void)
+{
+    diag("  >>>Test 1:  psArgument Get, Remove, Parse, and Help Fxns");
+    psMetadata *arg = NULL;
+    char *argv[25];
+    argv[0] = "./program";
+    argv[1] = "-string";
+    argv[2] = "new";
+    argv[3] = "-float";
+    argv[4] = "6.66";
+    argv[5] = "-double";
+    argv[6] = "0.666";
+    argv[7] = "-int";
+    argv[8] = "8";
+    argv[9] = "-int";
+    argv[10] = "16";
+    argv[11] = "-int";
+    argv[12] = "32";
+    argv[13] = "-int";
+    argv[14] = "64";
+    argv[15] = "-U8";
+    argv[16] = "1";
+    argv[17] = "-U16";
+    argv[18] = "666";
+    argv[19] = "-U32";
+    argv[20] = "666";
+    argv[21] = "-Bool";
+    argv[22] = "true";
+    argv[23] = "-int";
+    //    argv[24] = "32";
+    argv[24] = "-vvv";
+    int argc = 25;
+
+    //Try to get an argument's position
+    int i = psArgumentGet(argc, argv, "-float");
+    {
+        ok( i == 3,
+            "psArgumentGet:         return correct location of input argument.");
+    }
+    //Return 0 for attempting to get from a NULL input argument.
+    {
+        ok( psArgumentGet(argc, NULL, "-float") == 0,
+            "psArgumentGet:         return 0 for a NULL input argument.");
+    }
+    //Return 0 for attempting to find a NULL string
+    {
+        ok( psArgumentGet(argc, argv, NULL) == 0,
+            "psArgumentGet:         return 0 for a NULL input string.");
+    }
+    //Return 0 for attempting to find an empty string
+    {
+        ok( psArgumentGet(argc, argv, "") == 0,
+            "psArgumentGet:         return 0 for an empty input string.");
+    }
+    //Return 0 for attempting to get an argument that doesn't match
+    {
+        ok( psArgumentGet(argc, argv, "-xxx") == 0,
+            "psArgumentGet:         return 0 for an empty input string.");
+    }
+    //Return false for attempting to remove argnum = 0
+    {
+        ok( !psArgumentRemove(0, &argc, argv),
+            "psArgumentRemove:      return false for argnum = 0.");
+    }
+    //Return false for attempting to remove NULL argc
+    {
+        ok( !psArgumentRemove(0, NULL, argv),
+            "psArgumentRemove:      return false for NULL argc.");
+    }
+
+    //Setup the argument list for comparison
+    psMetadata *args = psMetadataAlloc();
+    psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString");
+    psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.666);
+    psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666);
+    psMetadata *ints = psMetadataAlloc();
+    psMetadataAdd(ints, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
+    psMetadataAdd(ints, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
+    psMetadataAdd(ints, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
+    psMetadataAdd(ints, PS_LIST_TAIL, "int4", PS_DATA_S64, "Int4", 64);
+    psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", ints);
+    psFree(ints);                  // Drop reference
+    psMetadataAddS32(args, PS_LIST_TAIL, "-multi", 0, "666", 2);
+    psMetadataAddS32(args, PS_LIST_TAIL, "-multi", PS_META_DUPLICATE_OK, "hello kitty", 1);
+
+    psMetadataAddU8(args, PS_LIST_TAIL, "-U8", 0, "U8", 1);
+    psMetadataAddU16(args, PS_LIST_TAIL, "-U16", 0, "U16", 666);
+    psMetadataAddU32(args, PS_LIST_TAIL, "-U32", 0, "U32", 666);
+    psMetadataAddU64(args, PS_LIST_TAIL, "-U64", 0, "U64", 666);
+    psMetadataAddBool(args, PS_LIST_TAIL, "-Bool", 0, "boolean", true);
+    psMetadataAddBool(args, PS_LIST_TAIL, "-Bool2", 0, "boolean", false);
+    psSphere *sphere = psSphereAlloc();
+    sphere->r = 6.66;
+    sphere->d = 666.666;
+    psMetadataAddPtr(args, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE, "", sphere);
+    psFree(sphere);
+
+    //psArgumentHelp test
+    //Do nothing for NULL input (exit gracefully)
+    psArgumentHelp(NULL);
+    //Print the Argument help for valid metadata
+    psArgumentHelp(args);
+
+    //psArgumentParse tests
+    //Return false for NULL input arguments
+    {
+        ok( !psArgumentParse(NULL, &argc, argv),
+            "psArgumentParse:       return false for NULL argument metadata input.");
+    }
+    //Return false for NULL input argc
+    {
+        ok( !psArgumentParse(args, NULL, argv),
+            "psArgumentParse:       return false for NULL argc input.");
+    }
+    //Return false for NULL input argv
+    {
+        ok( !psArgumentParse(args, &argc, NULL),
+            "psArgumentParse:       return false for NULL argv input.");
+    }
+    //Return false for argc = 0
+    {
+        int tempc = 0;
+        ok( !psArgumentParse(args, &tempc, argv),
+            "psArgumentParse:       return false for argc = 1 input.");
+    }
+    //Return false for string not found in metadata arguments
+    {
+        ok( !psArgumentParse(args, &argc, argv),
+            "psArgumentParse:      return false for argv containing unspecified input.");
+    }
+    //Return true for valid case
+    {
+        psArgumentRemove(25, &argc, argv);
+        ok( psArgumentParse(args, &argc, argv),
+            "psArgumentParse:      return true for valid inputs.");
+    }
+    //Return false for inconsistent argc in metadata
+    {
+        psMetadata *tempArg = psMetadataAlloc();
+        psMetadata *mdtemp = psMetadataAlloc();
+        psMetadataAdd(mdtemp, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
+        psMetadataAdd(mdtemp, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
+        psMetadataAdd(mdtemp, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
+        psMetadataAdd(tempArg, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", mdtemp);
+        psFree(mdtemp);
+        int argcc = 2;
+        char *argvv[2];
+        argvv[0] = "./program";
+        argvv[1] = "-string";
+        ok( !psArgumentParse(tempArg, &argcc, argvv),
+            "psArgumentParse:      return false for inconsistent argc.");
+        psFree(tempArg);
+    }
+    //Return false for argc = 1
+    {
+        int argcc = 2;
+        char *argvv[2];
+        argvv[0] = "./program";
+        argvv[1] = "-string";
+        ok( !psArgumentParse(args, &argcc, argvv),
+            "psArgumentParse:      return false for incomplete string syntax.");
+    }
+    //Return true for an unfound MULTI match
+    {
+        int argcc = 3;
+        char *argvv[3];
+        argvv[0] = "./program";
+        argvv[1] = "-multi";
+        argvv[2] = "2";
+        ok( psArgumentParse(args, &argcc, argvv),
+            "psArgumentParse:      return true for MULTI.");
+    }
+
+    //Check for Memory leaks
+    {
+        psFree(args);
+        psFree(arg);
+        checkMem();
+    }
+}
+
+void testArgumentVerbosity(void)
+{
+    diag("  >>>Test 2:  psArgumentRemove & psArgumentVerbosity Fxns");
+
+    //Return 2 (default) for NULL input argument
+    {
+        int argc = 1;
+        ok( psArgumentVerbosity(&argc, NULL) == 2,
+            "psArgumentVerbosity:  return 2 for NULL argument input.");
+    }
+    //Return 2 for NULL argc input
+    {
+        char *argv[1];
+        argv[0] = "./program";
+        ok( psArgumentVerbosity(NULL, argv) == 2,
+            "psArgumentVerbosity:  return 2 for NULL argument input.");
+    }
+    //Return 3 for "-v" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-v";
+        ok( psArgumentVerbosity(&argc, argv) == 3,
+            "psArgumentVerbosity:  return 3 for '-v' argument input.");
+    }
+    //Return 4 for "-vv" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-vv";
+        ok( psArgumentVerbosity(&argc, argv) == 4,
+            "psArgumentVerbosity:  return 4 for '-vv' argument input.");
+    }
+    //Return 5 for "-vvv" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-vvv";
+        ok( psArgumentVerbosity(&argc, argv) == 5,
+            "psArgumentVerbosity:  return 5 for '-vvv' argument input.");
+    }
+    //Return 2 for "-logfmt" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-logfmt";
+        ok( psArgumentVerbosity(&argc, argv) == 2,
+            "psArgumentVerbosity:  return 2 for '-logfmt' argument input.");
+    }
+    //Return 2 for "-logfmt" option with "H"
+    {
+        int argc = 3;
+        char *argv[3];
+        argv[0] = "./program";
+        argv[1] = "-logfmt";
+        argv[2] = "H";
+        ok( psArgumentVerbosity(&argc, argv) == 2,
+            "psArgumentVerbosity:  return 2 for '-logfmt H' argument inputs.");
+    }
+    //Return 2 for "-trace" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-trace";
+        ok( psArgumentVerbosity(&argc, argv) == 2,
+            "psArgumentVerbosity:  return 2 for '-trace' argument input.");
+    }
+    //Return 2 for "-trace 1 2" option
+    {
+        int argc = 4;
+        char *argv[4];
+        argv[0] = "./program";
+        argv[1] = "-trace";
+        argv[2] = "1";
+        argv[3] = "2";
+        ok( psArgumentVerbosity(&argc, argv) == 2,
+            "psArgumentVerbosity:  return 2 for '-trace 1 2' argument inputs.");
+    }
+    //Return 2 for "-trace-levels" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-trace-levels";
+        ok( psArgumentVerbosity(&argc, argv) == 2,
+            "psArgumentVerbosity:  return 2 for '-trace-levels' argument input.");
+    }
+
+    //Check for Memory leaks
+    {
+        checkMem();
+    }
+}
+
+void testLogTraceArguments(void)
+{
+    diag("  >>>Test 3:  psLogArguments & psTraceArguments Fxns");
+
+    //Return 2 (default) for NULL arguments input
+    {
+        int argc = 4;
+        ok( psLogArguments(&argc, NULL) == 2,
+            "psLogArguments:       return 2 for NULL argument input.");
+    }
+    //Return 2 (default) for NULL argc input
+    {
+        char *argv[1];
+        argv[0] = "./program";
+        ok( psLogArguments(NULL, argv) == 2,
+            "psLogArguments:       return 2 for NULL argc input.");
+    }
+    //Return 3 for "-v" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-v";
+        ok( psLogArguments(&argc, argv) == 3,
+            "psLogArguments:       return 3 for '-v' argument input.");
+    }
+    //Return 4 for "-vv" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-vv";
+        ok( psLogArguments(&argc, argv) == 4,
+            "psLogArguments:       return 4 for '-vv' argument input.");
+    }
+    //Return 5 for "-vvv" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-vvv";
+        ok( psLogArguments(&argc, argv) == 5,
+            "psLogArguments:       return 5 for '-vvv' argument input.");
+    }
+    //Return 2 for "-logfmt" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-logfmt";
+        ok( psLogArguments(&argc, argv) == 2,
+            "psLogArguments:       return 2 for '-logfmt' argument input.");
+    }
+    //Return 2 for "-logfmt" option with "H"
+    {
+        int argc = 3;
+        char *argv[3];
+        argv[0] = "./program";
+        argv[1] = "-logfmt";
+        argv[2] = "H";
+        ok( psLogArguments(&argc, argv) == 2,
+            "psLogArguments:       return 2 for '-logfmt H' argument inputs.");
+    }
+
+
+    //psTraceArguments Tests
+    //Return 0 (default) for NULL arguments input
+    {
+        int argc = 4;
+        ok( psTraceArguments(&argc, NULL) == 0,
+            "psTraceArguments:     return 0 for NULL argument input.");
+    }
+    //Return 0 (default) for NULL argc input
+    {
+        char *argv[1];
+        argv[0] = "./program";
+        ok( psTraceArguments(NULL, argv) == 0,
+            "psTraceArguments:     return 0 for NULL argc input.");
+    }
+    //Return 0 for "-trace" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-trace";
+        ok( psTraceArguments(&argc, argv) == 0,
+            "psTraceArguments:     return 2 for '-trace' argument input.");
+    }
+    //Return 2 for "-trace 1 2" option
+    {
+        int argc = 4;
+        char *argv[4];
+        argv[0] = "./program";
+        argv[1] = "-trace";
+        argv[2] = "1";
+        argv[3] = "2";
+        ok( psTraceArguments(&argc, argv) == 1,
+            "psTraceArguments:     return 2 for '-trace 1 2' argument inputs.");
+    }
+    //Return 2 for "-trace-levels" option
+    {
+        int argc = 2;
+        char *argv[2];
+        argv[0] = "./program";
+        argv[1] = "-trace-levels";
+        ok( psTraceArguments(&argc, argv) == 0,
+            "psTraceArguments:     return 2 for '-trace-levels' argument input.");
+    }
+
+    //Check for Memory leaks
+    {
+        checkMem();
+    }
+}
Index: trunk/psLib/test/types/tap_psMetadataItemCompare.c
===================================================================
--- trunk/psLib/test/types/tap_psMetadataItemCompare.c	(revision 8797)
+++ trunk/psLib/test/types/tap_psMetadataItemCompare.c	(revision 8805)
@@ -11,5 +11,5 @@
     psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true)
                            ;
-    plan_tests(21);
+    plan_tests(22);
 
     diag("psMetadataItemCompare() tests");
@@ -18,10 +18,10 @@
     {
         ok( !psMetadataItemCompare(compare, item),
-            "return false for NULL compare input." );
+            "psMetadataItemCompare:      return false for NULL compare input." );
     }
     //Return false for NULL template psMetadataItem
     {
         ok( !psMetadataItemCompare(item, template),
-            "return false for NULL template input." )
+            "psMetadataItemCompare:      return false for NULL template input." )
         ;
     }
@@ -35,5 +35,5 @@
     {
         ok( !psMetadataItemCompare(template, item),
-            "return false for input with different names." )
+            "psMetadataItemCompare:      return false for input with different names.")
         ;
     }
@@ -42,5 +42,5 @@
     {
         ok( psMetadataItemCompare(itemCopy, item),
-            "return true for comparison of identical psMetadataItem's." );
+            "psMetadataItemCompare:      return true for comparison of identical psMetadataItem's.");
     }
 
@@ -48,5 +48,5 @@
     {
         ok( psMetadataItemCompare(compare, item),
-            "return true for valid compare of different type." );
+            "psMetadataItemCompare:      return true for valid compare of different type.");
     }
 
@@ -56,10 +56,10 @@
     {
         ok( psMetadataItemCompare(compare, item),
-            "return false for comparison of F64 to bool." );
+            "psMetadataItemCompare:      return false for comparison of F64 to bool." );
     }
     //Return true for comparing F64 with Bool
     {
         ok( psMetadataItemCompare(item, compare),
-            "return false for comparison of bool to F64." );
+            "psMetadataItemCompare:      return false for comparison of bool to F64." );
     }
 
@@ -73,5 +73,5 @@
     {
         ok( psMetadataItemCompare(compare, template),
-            "return true for comparison of S32 to F32." )
+            "psMetadataItemCompare:      return true for comparison of S32 to F32." )
         ;
     }
@@ -79,5 +79,5 @@
     {
         ok( psMetadataItemCompare(template, compare),
-            "return true for comparison of F32 to S32." )
+            "psMetadataItemCompare:      return true for comparison of F32 to S32." )
         ;
     }
@@ -92,5 +92,5 @@
     {
         ok( psMetadataItemCompare(compare, template),
-            "return true for comparison of S16 to U32." )
+            "psMetadataItemCompare:     return true for comparison of S16 to U32." )
         ;
     }
@@ -98,5 +98,5 @@
     {
         ok( psMetadataItemCompare(template, compare),
-            "return true for comparison of U32 to S16." )
+            "psMetadataItemCompare:     return true for comparison of U32 to S16." )
         ;
     }
@@ -111,5 +111,5 @@
     {
         ok( psMetadataItemCompare(compare, template),
-            "return true for comparison of U8 to U16." )
+            "psMetadataItemCompare:     return true for comparison of U8 to U16." )
         ;
     }
@@ -117,5 +117,5 @@
     {
         ok( psMetadataItemCompare(template, compare),
-            "return true for comparison of U16 to U8." )
+            "psMetadataItemCompare:     return true for comparison of U16 to U8." )
         ;
     }
@@ -126,5 +126,5 @@
     {
         ok( psMetadataItemCompare(compare, template),
-            "return true for comparison of U8 to S8." )
+            "psMetadataItemCompare:     return true for comparison of U8 to S8." )
         ;
     }
@@ -132,5 +132,5 @@
     {
         ok( psMetadataItemCompare(template, compare),
-            "return true for comparison of S8 to U8." )
+            "psMetadataItemCompare:     return true for comparison of S8 to U8." )
         ;
     }
@@ -141,5 +141,6 @@
     {
         ok( !psMetadataItemCompare(compare, template),
-            "return false for comparison of U8 to S64*.  *not yet implemented" )
+            "psMetadataItemCompare:     return false for comparison of U8 to S64*.  "
+            "*not yet implemented" )
         ;
     }
@@ -147,5 +148,6 @@
     {
         ok( !psMetadataItemCompare(template, compare),
-            "return false for comparison of S64* to U8.  *not yet implemented" )
+            "psMetadataItemCompare:     return false for comparison of S64* to U8.  "
+            "*not yet implemented" )
         ;
     }
@@ -160,5 +162,5 @@
     {
         ok( !psMetadataItemCompare(compare, template),
-            "return false for comparison of different psString's." )
+            "psMetadataItemCompare:     return false for comparison of different psString's.")
         ;
     }
@@ -171,5 +173,5 @@
     {
         ok( psMetadataItemCompare(compare, template),
-            "return true for comparison of identical psString's." )
+            "psMetadataItemCompare:     return true for comparison of identical psString's.")
         ;
     }
@@ -182,5 +184,15 @@
     {
         ok( !psMetadataItemCompare(compare, template),
-            "return false for comparison of psString with bool." )
+            "psMetadataItemCompare:     return false for comparison of psString with bool.")
+        ;
+    }
+    //Return false for comparing bool with string
+    psFree(template)
+    ;
+    template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false)
+               ;
+    {
+        ok( !psMetadataItemCompare(template, compare),
+            "psMetadataItemCompare:     return false for comparison of psString with bool.")
         ;
     }
Index: trunk/psLib/test/types/tst_psArguments.c
===================================================================
--- trunk/psLib/test/types/tst_psArguments.c	(revision 8797)
+++ trunk/psLib/test/types/tst_psArguments.c	(revision 8805)
@@ -5,6 +5,6 @@
 *  @author  David Robbins, MHPCC
 *
-*  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2006-06-09 01:25:42 $
+*  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2006-09-13 02:20:15 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -12,20 +12,20 @@
 */
 
-#include "psTest.h"
-#include "pslib_strict.h"
+#include "pslib.h"
 
 static psS32 testArgument(void);
-
+/*
 testDescription tests[] = {
                               {testArgument, 666, "Test psArgument fxns", 0, false},
                               {NULL}
                           };
-
+*/
 int main(int argc, char* argv[])
 {
     psLogSetLevel( PS_LOG_INFO );
-    if( !runTestSuite(stderr,"psArguments",tests,argc,argv)) {
-        return 1;
-    }
+    testArgument();
+    //    if( !runTestSuite(stderr,"psArguments",tests,argc,argv)) {
+    //        return 1;
+    //    }
     return 0;
 }