Index: /trunk/psLib/src/types/psArguments.c =================================================================== --- /trunk/psLib/src/types/psArguments.c (revision 8804) +++ /trunk/psLib/src/types/psArguments.c (revision 8805) @@ -7,6 +7,6 @@ * @author David Robbins, MHPCC * - * @version $Revision: 1.11 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-08-26 04:34:28 $ + * @version $Revision: 1.12 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-09-13 02:20:15 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -24,11 +24,16 @@ #include "psLogMsg.h" #include "psTrace.h" +#include "psAssert.h" #define NUM_SPACES 4 // Number of spaces between // Set verbosity level -int psArgumentVerbosity(int *argc, char **argv) +int psArgumentVerbosity(int *argc, + char **argv) { int logLevel = 2; // Default log level + psLogSetLevel(logLevel); + PS_ASSERT_PTR_NON_NULL(argv, 2); + PS_ASSERT_PTR_NON_NULL(argc, 2); int argnum = 0; // Argument number @@ -63,4 +68,5 @@ if ( (*argc < argnum + 3) ) { psError(PS_ERR_IO, true, "-trace switch specified without facility and level."); + return logLevel; } psArgumentRemove(argnum, argc, argv); @@ -71,5 +77,6 @@ if ((argnum = psArgumentGet(*argc, argv, "-trace-levels"))) { psTracePrintLevels(); - exit(2); + // exit(2); + return logLevel; } @@ -78,6 +85,12 @@ // Find the location of the specified argument -int psArgumentGet(int argc, char **argv, const char *arg) -{ +int psArgumentGet(int argc, + char **argv, + const char *arg) +{ + PS_ASSERT_PTR_NON_NULL(argv, 0); + PS_ASSERT_PTR_NON_NULL(arg, 0); + if (strlen(arg) == 0) + return 0; for (int i = 1; i < argc; i++) { if (!strcmp(argv[i], arg)) @@ -89,6 +102,10 @@ // Remove the specified argument (by location) -bool psArgumentRemove(int argnum, int *argc, char **argv) -{ +bool psArgumentRemove(int argnum, + int *argc, + char **argv) +{ + PS_ASSERT_PTR_NON_NULL(argv, false); + PS_ASSERT_PTR_NON_NULL(argc, false); if (argnum > 0) { (*argc)--; @@ -148,4 +165,9 @@ char **argv) { + PS_ASSERT_PTR_NON_NULL(arguments, false); + PS_ASSERT_PTR_NON_NULL(argv, false); + PS_ASSERT_PTR_NON_NULL(argc, false); + if (*argc < 1) + return false; // We need to do a bit of mucking around in order to preserve the arguments metadata until the last // minute --- if there is a bad argument, we need to return the old "arguments", since they contain @@ -174,5 +196,6 @@ } - psMetadataIterator *paramsIter = psMetadataIteratorAlloc(params, PS_LIST_HEAD, NULL);// Iter + psMetadataIterator *paramsIter = psMetadataIteratorAlloc(params, + PS_LIST_HEAD, NULL);// Iter psMetadataItem *param = NULL; // Parameter from iteration while ((param = psMetadataGetAndIncrement(paramsIter))) { @@ -252,7 +275,9 @@ LENGTH_CASE(U16); LENGTH_CASE(U32); + LENGTH_CASE(U64); LENGTH_CASE(S8); LENGTH_CASE(S16); LENGTH_CASE(S32); + LENGTH_CASE(S64); case PS_DATA_F32: return arg->data.F32 >= 0 ? 12 : 13; // -d.dddddde?dd @@ -264,5 +289,8 @@ return arg->data.V ? strlen(arg->data.V) : 0; default: - psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type); + psError(PS_ERR_BAD_PARAMETER_TYPE, true, + "Argument type (%x) is not supported.\n", arg->type); + return 0; + // psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type); } @@ -279,6 +307,6 @@ static void printValueComment(psMetadataItem *item, // Argument item for which to print const char *comment, // Comment to print - unsigned int numSpaces // Number of spaces - ) + unsigned int numSpaces) // Number of spaces + { int valueLength = 0; // Length of the value portion @@ -287,10 +315,12 @@ // Print the value switch (item->type) { - PRINT_CASE(U8,"%d"); - PRINT_CASE(U16,"%d"); - PRINT_CASE(U32,"%d"); + PRINT_CASE(U8,"%u"); + PRINT_CASE(U16,"%u"); + PRINT_CASE(U32,"%u"); + PRINT_CASE(U64,"%lu"); PRINT_CASE(S8,"%d"); PRINT_CASE(S16,"%d"); PRINT_CASE(S32,"%d"); + PRINT_CASE(S64,"%ld"); PRINT_CASE(F32,"%.6e"); PRINT_CASE(F64,"%.6e"); @@ -308,5 +338,8 @@ break; default: - psAbort(__func__, "Argument type (%x) for %s is not supported.\n", item->type, item->name); + // psAbort(__func__, "Argument type (%x) for %s is not supported.\n", + // item->type, item->name); + psError(PS_ERR_BAD_PARAMETER_TYPE, true, + "Argument type (%x) for %s is not supported.\n", item->type, item->name); } valueLength = argLength(item); @@ -331,10 +364,11 @@ static void maxLength(int *maxName, // Maximum length of the name int *maxValue, // Maximum length of the value - psMetadata *md // Metadata for which to check the length - ) + psMetadata *md) // Metadata for which to check the length + { psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); // Iterator psMetadataItem *item = NULL; // Item from iteration - while ((item = psMetadataGetAndIncrement(iter))) { + while ((item = psMetadataGetAndIncrement(iter))) + { if (item->type == PS_DATA_METADATA) { maxLength(maxName, maxValue, item->data.V); @@ -357,4 +391,6 @@ void psArgumentHelp(psMetadata *arguments) { + if (arguments == NULL) + return; printf("Optional arguments, with default values:\n"); int maxName = 4; // Maximum length of a name @@ -384,5 +420,33 @@ psMetadataItem *multiCheck = psMetadataLookup(arguments, argItem->name); // Item to check for MULTI if (multiCheck->type == PS_DATA_METADATA_MULTI) { - printValueComment(NULL, argItem->comment, maxValue + NUM_SPACES); + bool first = true; // Is this the first one? + psListIterator* iter = psListIteratorAlloc(multiCheck->data.list,PS_LIST_HEAD,true); + psMetadataItem* listItem; + int count = 0; + // while ((listItem=(psMetadataItem*)psListGetAndIncrement(iter)) != NULL) { + while ((listItem=(psMetadataItem*)psListGetAndIncrement(iter)) != NULL) { + // for (int i = 0; i < NUM_SPACES; i++) { + // printf(" "); + // } + // printf("%s", listItem->name); + // int position = strlen(listItem->name); // Number of spaces in + // for (int i = position; i < maxName + NUM_SPACES; i++) { + // printf(" "); + // } + if (!first) { + for (int i = 0; i < maxName + 2*NUM_SPACES; i++) { + printf(" "); + } + } + printValueComment(listItem, listItem->comment, maxValue + NUM_SPACES); + first = false; + count++; + // continue; + } + psFree(iter); + while (count > 1) { + argItem = psMetadataGetAndIncrement(argIter); + count--; + } continue; } @@ -416,7 +480,7 @@ // we have log levels 1 (Error), 2 (Warning), 3 (Info), 4 (Details), 5 (Minutiae) // 2 = default, -v = 3, -vv = 4, -vvv = 5 -psS32 psLogArguments (int *argc, char **argv) -{ - +psS32 psLogArguments (int *argc, + char **argv) +{ int N, level; @@ -424,4 +488,7 @@ level = 2; + psLogSetLevel (level); + PS_ASSERT_PTR_NON_NULL(argv, 2); + PS_ASSERT_PTR_NON_NULL(argc, 2); // set in order, so that -vvv overrides -vv overrides -v if ((N = psArgumentGet (*argc, argv, "-v"))) { @@ -440,9 +507,11 @@ if ((N = psArgumentGet (*argc, argv, "-logfmt"))) { if (*argc < N + 2) { - psAbort ("psLogArguments", "USAGE: -logfmt (format)"); - } - psArgumentRemove (N, argc, argv); - psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid - psArgumentRemove (N, argc, argv); + // psAbort ("psLogArguments", "USAGE: -logfmt (format)"); + psError(PS_ERR_IO, true, "-logfmt switch specified without a format."); + } else { + psArgumentRemove (N, argc, argv); + psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid + psArgumentRemove (N, argc, argv); + } } @@ -453,13 +522,17 @@ // set trace levels by facility -psS32 psTraceArguments (int *argc, char **argv) -{ - +psS32 psTraceArguments (int *argc, + char **argv) +{ int N; + PS_ASSERT_PTR_NON_NULL(argv, 0); + PS_ASSERT_PTR_NON_NULL(argc, 0); // argument format is: -trace (facil) (level) while ((N = psArgumentGet (*argc, argv, "-trace"))) { if (*argc < N + 3) { - psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)"); + // psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)"); + psError(PS_ERR_IO, true, "-trace switch specified without facility and level."); + return 0; } psArgumentRemove (N, argc, argv); @@ -470,5 +543,6 @@ if ((N = psArgumentGet (*argc, argv, "-trace-levels"))) { psTracePrintLevels (); - exit (2); + // exit (2); + return 0; } return (TRUE); Index: /trunk/psLib/test/types/Makefile.am =================================================================== --- /trunk/psLib/test/types/Makefile.am (revision 8804) +++ /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 8804) +++ /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 , (C) 2006 + * + * Copyright: See COPYING file that comes with this distribution + * + */ + +#include + +#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 8804) +++ /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 8804) +++ /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; }