IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 6187


Ignore:
Timestamp:
Jan 23, 2006, 1:52:15 PM (20 years ago)
Author:
drobbin
Message:

Created psArguments.[ch] and moved psArguments fxn in from psMetadata (& tests).

Location:
trunk/psLib
Files:
5 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astro/psSphereOps.h

    r6039 r6187  
    66 *
    77 *  @author Robert DeSonia, MHPCC
    8  *
    9  *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-01-18 23:49:06 $
     8 *  @author David Robbins, MHPCC
     9 *
     10 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-01-23 23:52:15 $
    1112 *
    1213 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/src/pslib_strict.h

    r6185 r6187  
    99*  @author Eric Van Alst, MHPCC
    1010*
    11 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2006-01-23 20:44:29 $
     11*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2006-01-23 23:52:15 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    115115#include "psMetadataConfig.h"
    116116#include "psPixels.h"
     117#include "psArguments.h"
    117118/// @}
    118119

  • trunk/psLib/src/types/Makefile.am

    r5302 r6187  
    1212        psMetadata.c \
    1313        psMetadataConfig.c \
    14         psPixels.c
     14        psPixels.c \
     15        psArguments.c
    1516
    1617EXTRA_DIST = types.i
    … …  
    2526        psMetadata.h \
    2627        psMetadataConfig.h \
    27         psPixels.h
     28        psPixels.h \
     29        psArguments.h

  • trunk/psLib/src/types/psMetadata.c

    r6184 r6187  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.93 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-01-23 20:04:31 $
     14 *  @version $Revision: 1.94 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-01-23 23:52:15 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    992992}
    993993
    994 
    995 // Set verbosity level
    996 int psArgumentVerbosity(int *argc, char **argv)
    997 {
    998     int logLevel = 2;   // Default log level
    999     int argnum = 0;   // Argument number
    1000 
    1001     // set in order, so that -vvv overrides -vv overrides -v
    1002     if ( (argnum = psArgumentGet(*argc, argv, "-v")) ) {
    1003         psArgumentRemove(argnum, argc, argv);
    1004         logLevel = 3;
    1005     }
    1006     if ( (argnum = psArgumentGet(*argc, argv, "-vv")) ) {
    1007         psArgumentRemove(argnum, argc, argv);
    1008         logLevel = 4;
    1009     }
    1010     if ( (argnum = psArgumentGet(*argc, argv, "-vvv")) ) {
    1011         psArgumentRemove(argnum, argc, argv);
    1012         logLevel = 5;
    1013     }
    1014     psLogSetLevel(logLevel);  // XXX: This function should return an error if the log level is invalid
    1015 
    1016     if ( (argnum = psArgumentGet(*argc, argv, "-logfmt")) ) {
    1017         if (*argc < argnum + 2) {
    1018             psError(PS_ERR_IO, true, "-logfmt switch specified without a format.");
    1019         } else {
    1020             psArgumentRemove(argnum, argc, argv);
    1021             psLogSetFormat(argv[argnum]); // XXX EAM : this function should return an error if the log format is invalid
    1022             psArgumentRemove(argnum, argc, argv);
    1023         }
    1024     }
    1025 
    1026     // Now the trace stuff
    1027     // argument format is: -trace (facil) (level)
    1028     while ( (argnum = psArgumentGet(*argc, argv, "-trace")) ) {
    1029         if ( (*argc < argnum + 3) ) {
    1030             psError(PS_ERR_IO, true, "-trace switch specified without facility and level.");
    1031         }
    1032         psArgumentRemove(argnum, argc, argv);
    1033         psTraceSetLevel(argv[argnum], atoi(argv[argnum+1])); // XXX: This function should return an error if the trace level is invalid
    1034         psArgumentRemove(argnum, argc, argv);
    1035         psArgumentRemove(argnum, argc, argv);
    1036     }
    1037     if ((argnum = psArgumentGet(*argc, argv, "-trace-levels"))) {
    1038         psTracePrintLevels();
    1039         exit(2);
    1040     }
    1041 
    1042     return logLevel;
    1043 }
    1044 
    1045 // Find the location of the specified argument
    1046 int psArgumentGet(int argc, char **argv, const char *arg)
    1047 {
    1048     for (int i = 1; i < argc; i++) {
    1049         if (!strcmp(argv[i], arg))
    1050             return i;
    1051     }
    1052 
    1053     return 0;
    1054 }
    1055 
    1056 // Remove the specified argument (by location)
    1057 bool psArgumentRemove(int argnum, int *argc, char **argv)
    1058 {
    1059     if (argnum > 0) {
    1060         (*argc)--;
    1061         for (int i = argnum; i < *argc; i++) {
    1062             argv[i] = argv[i+1];
    1063         }
    1064     } else {
    1065         return false;
    1066     }
    1067 
    1068     return true;
    1069 }
    1070 
    1071 
    1072 static psMetadataItem *argumentRead(psMetadataItem *item, // Item to read into
    1073                                     int argnum, // Argument number
    1074                                     int *argc, // Number of arguments in total
    1075                                     char **argv) // The arguments
    1076 
    1077 {
    1078     psMetadataItem *newItem = NULL;
    1079     switch(item->type)
    1080     {
    1081         // Only doing a representative set of types
    1082     case PS_DATA_S32:
    1083         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atoi(argv[argnum]));
    1084         psArgumentRemove(argnum, argc, argv);
    1085         break;
    1086     case PS_DATA_F32:
    1087         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, atof(argv[argnum]));
    1088         psArgumentRemove(argnum, argc, argv);
    1089         break;
    1090     case PS_DATA_BOOL:
    1091         // Turn option on; no optional argument to remove
    1092         newItem = psMetadataItemAlloc(item->name, item->type, item->comment, true);
    1093         break;
    1094         // XXX: Include the other numerical types
    1095     case PS_DATA_STRING: {
    1096             //psString string = psStringCopy(argv[argnum]); // Get the argument into PS memory management
    1097             //psFree(string);
    1098             newItem = psMetadataItemAlloc(item->name, item->type, item->comment, argv[argnum]);
    1099             psArgumentRemove(argnum, argc, argv);
    1100         }
    1101         break;
    1102     default:
    1103         psError(PS_ERR_IO, true, "Argument type (%x) is not supported --- argument %s ignored\n",
    1104                 item->type, item->name);
    1105         psFree(newItem);
    1106         return NULL;
    1107     }
    1108 
    1109     return newItem;
    1110 }
    1111 
    1112 
    1113 // XXX: There is a memory leak in the MULTI section.  I think it might have something to do with reference
    1114 // counting between lists and MD, in the second section of the code (copy newArgs into arguments), but I'm not
    1115 // entirely sure.
    1116 bool psArgumentParse(psMetadata *arguments,
    1117                      int *argc,
    1118                      char **argv)
    1119 {
    1120     // We need to do a bit of mucking around in order to preserve the arguments metadata until the last
    1121     // minute --- if there is a bad argument, we need to return the old "arguments", since they contain
    1122     // the default values, which we probably want to output in a "help" message (we don't want to print
    1123     // the changed values and have the user think that they are default values).
    1124 
    1125     psMetadata *newArgs = psMetadataAlloc(); // Place to read arguments into
    1126     psList *changed = psListAlloc(NULL);// List of keys that have changed
    1127 
    1128     for (int i = 1; i < *argc; i++) {
    1129         psTrace(__func__, 7, "Looking at %s\n", argv[i]);
    1130         psMetadataItem *argItem = psMetadataLookup(arguments, argv[i]);
    1131         if (argItem) {
    1132             psArgumentRemove(i, argc, argv); // Remove the switch
    1133             if (argItem->type != PS_DATA_METADATA_MULTI) {
    1134                 if (argItem->type != PS_DATA_BOOL && *argc < i + 1) {
    1135                     psError(PS_ERR_IO, true, "Required argument for %s is missing.\n", argItem->name);
    1136                     // XXX: Cleanup before returning
    1137                     psFree(newArgs);
    1138                     return false;
    1139                 }
    1140                 psMetadataItem *newItem = argumentRead(argItem, i, argc, argv);
    1141                 psMetadataAddItem(newArgs, newItem, PS_LIST_TAIL, PS_META_REPLACE);
    1142                 psFree(newItem);
    1143             } else {
    1144                 // Go through the MULTI
    1145                 psList *multi = argItem->data.V; // The list of MULTI psMetadataItems
    1146                 if (*argc < i + multi->n) {
    1147                     psError(PS_ERR_IO, true, "Not enough arguments for %s.\n", argItem->name);
    1148                     // Remove the arguments --- they will be ignored
    1149                     for (int j = i; j < *argc; j++) {
    1150                         psArgumentRemove(i, argc, argv);
    1151                     }
    1152                     // XXX: Cleanup before returning
    1153                     psFree(newArgs);
    1154                     return false;
    1155                 }
    1156 
    1157                 // Remove any prior existence in the newArgs --- this is important because we specify
    1158                 // adding the new items as DUPLICATE_OK, so if some idiot specifies it twice, we'd end
    1159                 // up with two copies of everything.
    1160                 psMetadataItem *checkItem = psMetadataLookup(newArgs, argItem->name);
    1161                 if (checkItem) {
    1162                     (void)psMetadataRemove(newArgs, 0, argItem->name);
    1163                     (void)psListRemoveData(changed, argItem->name);
    1164                 }
    1165 
    1166                 psListIterator *multiIter = psListIteratorAlloc(multi, PS_LIST_HEAD, true);
    1167                 psMetadataItem *nextItem = NULL; // Item from list
    1168                 while ( (nextItem = psListGetAndIncrement(multiIter)) ) {
    1169                     psMetadataItem *newItem = argumentRead(nextItem, i, argc, argv);
    1170                     psMetadataAddItem(newArgs, newItem, PS_LIST_TAIL, PS_META_DUPLICATE_OK);
    1171                     //psFree(newItem);
    1172                 }
    1173                 psFree(multiIter);
    1174             }
    1175 
    1176             // Some book-keeping
    1177             //     psString name = psStringCopy(argItem->name);
    1178             psListAdd(changed, PS_LIST_TAIL, argItem->name);
    1179             i--;
    1180 
    1181         } else if ( (strncmp(argv[i], "-", 1) == 0 ) || (strncmp(argv[i], "+", 1) == 0) ) {
    1182             // Someone's specified a bad option
    1183             psError(PS_ERR_IO, true, "Unknown option: %s\n", argv[i]);
    1184             psFree(newArgs);
    1185             return false;
    1186         }
    1187     }
    1188 
    1189     // All the arguments are good, so now we can copy the newArgs over
    1190     psListIterator *changedIter = psListIteratorAlloc(changed, PS_LIST_HEAD, false); // Iterator
    1191     psString name = NULL;  // Item from iteration
    1192     while ( (name = psListGetAndIncrement(changedIter)) ) {
    1193         printf("Updating %s\n", name);
    1194         psMetadataItem *oldItem = psMetadataLookup(arguments, name);
    1195         psMetadataItem *newItem = psMetadataLookup(newArgs, name);
    1196         if ( (oldItem->type != newItem->type) ) {
    1197             psAbort(__func__, "Shouldn't reach here!\n");
    1198         }
    1199         switch (oldItem->type) {
    1200             // Only doing a representative set of types
    1201         case PS_DATA_S32:
    1202             oldItem->data.S32 = newItem->data.S32;
    1203             break;
    1204         case PS_DATA_F32:
    1205             oldItem->data.F32 = newItem->data.F32;
    1206             break;
    1207         case PS_DATA_BOOL:
    1208             oldItem->data.B = newItem->data.B;
    1209             break;
    1210             // XXX: Include the other numerical types
    1211         case PS_DATA_STRING:
    1212             psFree(oldItem->data.V);
    1213             oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
    1214             break;
    1215         case PS_DATA_METADATA_MULTI: {
    1216                 psList *newMulti = psMemIncrRefCounter(newItem->data.V); // The new list of MULTI
    1217                 psList *oldMulti = oldItem->data.V; // The old list of MULTI
    1218                 psListIterator *newMultiIter = psListIteratorAlloc(newMulti, PS_LIST_HEAD, false);
    1219                 psListIterator *oldMultiIter = psListIteratorAlloc(oldMulti, PS_LIST_HEAD, true);
    1220                 psMetadataItem *newMultiItem = NULL; // Item from iterator
    1221                 while ( (newMultiItem = psListGetAndIncrement(newMultiIter)) ) {
    1222                     psMetadataItem *oldMultiItem = psListGetAndIncrement(oldMultiIter);
    1223                     if (!oldMultiItem) {
    1224                         psAbort(__func__,
    1225                                 "Something went very wrong here!  The lists SHOULD be of the same length!\n");
    1226                     }
    1227                     switch (oldMultiItem->type) {
    1228                         // Only doing a representative set of types
    1229                     case PS_DATA_S32:
    1230                         oldItem->data.S32 = newItem->data.S32;
    1231                         break;
    1232                     case PS_DATA_F32:
    1233                         oldItem->data.F32 = newItem->data.F32;
    1234                         break;
    1235                         // XXX: Include the other numerical types
    1236                     case PS_DATA_STRING:
    1237                         psFree(oldItem->data.V);
    1238                         oldItem->data.V = psMemIncrRefCounter(newItem->data.V);
    1239                         break;
    1240                     default:
    1241                         psAbort(__func__, "Should never ever get here, ever.\n");
    1242                     }
    1243                     psFree(oldMultiItem);
    1244                     psFree(newMultiItem);
    1245                 }
    1246                 psFree(newMultiIter);
    1247                 psFree(oldMultiIter);
    1248             }
    1249             break;
    1250         default:
    1251             psAbort(__func__, "Should never ever ever get here.\n");
    1252         }
    1253     }
    1254     psFree(changedIter);
    1255     psFree(changed);
    1256 
    1257     // Now, blow away the newArgs and we're done.
    1258     psFree(newArgs);
    1259     return true;
    1260 }
    1261 
    1262 
    1263 static int argLength(psMetadataItem *arg)
    1264 {
    1265     switch (arg->type) {
    1266         // Only doing a representative set of types
    1267     case PS_DATA_S32:
    1268         return arg->data.S32 >= 0 ? (int)log10f((float)arg->data.S32) + 1 :
    1269                (int)log10f(-(float)arg->data.S32) + 2;
    1270         // XXX: Other numerical types
    1271     case PS_DATA_F32:
    1272         return arg->data.F32 >= 0 ? 12 : 13; // -d.dddddde?dd
    1273     case PS_DATA_F64:
    1274         return arg->data.F64 >= 0 ? 12 : 13; // -d.dddddde?dd
    1275     case PS_DATA_BOOL:
    1276         return arg->data.B ? 4 : 5;
    1277     case PS_DATA_STRING:
    1278         return strlen(arg->data.V);
    1279     default:
    1280         psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type);
    1281     }
    1282 
    1283     return 0;
    1284 }
    1285 
    1286 #define NUM_SPACES 4   // Number of spaces between
    1287 
    1288 void psArgumentHelp(psMetadata *arguments)
    1289 {
    1290     printf("Optional arguments, with default values:\n");
    1291     psMetadataIterator *argIter = psMetadataIteratorAlloc(arguments, PS_LIST_HEAD, NULL);
    1292     psMetadataItem *argItem = NULL; // Item from iterator
    1293     int maxName = 4;   // Maximum length of a name
    1294     int maxValue = 4;   // Maximum length of a value
    1295 
    1296     // First pass to get the sizes
    1297     while ( (argItem = psMetadataGetAndIncrement(argIter)) ) {
    1298         if (strlen(argItem->name) > maxName) {
    1299             maxName = strlen(argItem->name);
    1300         }
    1301         int valLength = argLength(argItem);
    1302         if (valLength > maxValue) {
    1303             maxValue = valLength;
    1304         }
    1305     }
    1306 
    1307     // Second pass to print
    1308     psMetadataIteratorSet(argIter, PS_LIST_HEAD);
    1309     psString lastName = NULL;  // Last name we printed
    1310     while ( (argItem = psMetadataGetAndIncrement(argIter)) ) {
    1311         // Initial indent
    1312         for (int i = 0; i < NUM_SPACES; i++) {
    1313             printf(" ");
    1314         }
    1315 
    1316         // Print the name if required
    1317         int position = 0; // Number of spaces in
    1318         if (! lastName || strcmp(lastName, argItem->name) != 0) {
    1319             // A new name
    1320             printf("%s", argItem->name);
    1321             position += strlen(argItem->name);
    1322             lastName = argItem->name;
    1323         }
    1324         for (int i = position; i < maxName + NUM_SPACES; i++) {
    1325             printf(" ");
    1326         }
    1327 
    1328         // Print the value
    1329         printf("(");
    1330         switch (argItem->type) {
    1331             // Only doing a representative set of types
    1332         case PS_DATA_S32:
    1333             printf("%d", argItem->data.S32);
    1334             break;
    1335             // XXX: Other numerical types
    1336         case PS_DATA_F32:
    1337             printf("%.6e", argItem->data.F32);
    1338             break;
    1339         case PS_DATA_F64:
    1340             printf("%.6e", argItem->data.F64);
    1341             break;
    1342         case PS_DATA_BOOL:
    1343             if (argItem->data.B) {
    1344                 printf("TRUE");
    1345             } else {
    1346                 printf("FALSE");
    1347             }
    1348             break;
    1349         case PS_DATA_STRING:
    1350             printf("%s", (char*)(argItem->data.V));
    1351             break;
    1352         default:
    1353             psAbort(__func__, "Argument type (%x) is not supported.\n", argItem->type);
    1354         }
    1355         printf(")");
    1356         for (int i = argLength(argItem); i < maxValue + NUM_SPACES; i++) {
    1357             printf(" ");
    1358         }
    1359 
    1360         // Print the comment
    1361         if (argItem->comment) {
    1362             printf("%s", argItem->comment);
    1363         }
    1364         printf("\n");
    1365     }
    1366 
    1367     psFree(argIter);
    1368 }
    1369 
    1370 // we have log levels 1 (Error), 2 (Warning), 3 (Info), 4 (Details), 5 (Minutiae)
    1371 // 2 = default, -v = 3, -vv = 4, -vvv = 5
    1372 psS32 psLogArguments (int *argc, char **argv)
    1373 {
    1374 
    1375     int N, level;
    1376 
    1377     // default log level is 2
    1378     level = 2;
    1379 
    1380     // set in order, so that -vvv overrides -vv overrides -v
    1381     if ((N = psArgumentGet (*argc, argv, "-v"))) {
    1382         psArgumentRemove (N, argc, argv);
    1383         level = 3;
    1384     }
    1385     if ((N = psArgumentGet (*argc, argv, "-vv"))) {
    1386         psArgumentRemove (N, argc, argv);
    1387         level = 4;
    1388     }
    1389     if ((N = psArgumentGet (*argc, argv, "-vvv"))) {
    1390         psArgumentRemove (N, argc, argv);
    1391         level = 5;
    1392     }
    1393 
    1394     if ((N = psArgumentGet (*argc, argv, "-logfmt"))) {
    1395         if (*argc < N + 2) {
    1396             psAbort ("psLogArguments", "USAGE: -logfmt (format)");
    1397         }
    1398         psArgumentRemove (N, argc, argv);
    1399         psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid
    1400         psArgumentRemove (N, argc, argv);
    1401     }
    1402 
    1403     // set the level, return the level
    1404     psLogSetLevel (level);
    1405     return (level);
    1406 }
    1407 
    1408 // set trace levels by facility
    1409 psS32 psTraceArguments (int *argc, char **argv)
    1410 {
    1411 
    1412     int N;
    1413 
    1414     // argument format is: -trace (facil) (level)
    1415     while ((N = psArgumentGet (*argc, argv, "-trace"))) {
    1416         if (*argc < N + 3) {
    1417             psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)");
    1418         }
    1419         psArgumentRemove (N, argc, argv);
    1420         psTraceSetLevel (argv[N], atoi(argv[N+1]));
    1421         psArgumentRemove (N, argc, argv);
    1422         psArgumentRemove (N, argc, argv);
    1423     }
    1424     if ((N = psArgumentGet (*argc, argv, "-trace-levels"))) {
    1425         psTracePrintLevels ();
    1426         exit (2);
    1427     }
    1428     return (TRUE);
    1429 }
    1430 

  • trunk/psLib/src/types/psMetadata.h

    r6039 r6187  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.72 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2006-01-18 23:49:06 $
     13*  @version $Revision: 1.73 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2006-01-23 23:52:15 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    732732);
    733733
    734 /** Implements the various verbosity controls.
    735  *
    736  *  Arguments shall be removed from the argument list as they are processed.
    737  *
    738  *  @return int:        The resultant logging level.
    739  */
    740 int psArgumentVerbosity(
    741     int *argc,                         ///< number or arguments
    742     char **argv                        ///< the argument list
    743 );
    744 
    745 /** Checks for an argument and returns its index position if found.
    746  *
    747  *  @return int:        The index of the element in the argument list, otherwise 0.
    748  */
    749 int psArgumentGet(
    750     int argc,                          ///< number or arguments
    751     char **argv,                       ///< the argument list
    752     const char *arg                    ///< the specified argument to match
    753 );
    754 
    755 /** Removes from the argument list the argument whose index is argnum.
    756  *
    757  *  The number of entries in the argument list shall be decremented.
    758  *
    759  *  @return bool:       True if the argnum is in the argument list, otherwise false.
    760  */
    761 bool psArgumentRemove(
    762     int argnum,                        ///< the argument to remove
    763     int *argc,                         ///< number or arguments
    764     char **argv                        ///< the argument list
    765 );
    766 
    767 /** Parses the command line arguments into a metadata container of arguments.
    768  *
    769  *  The input arguments shall contain the list of possible arguments as the keywords providing
    770  *  the default values.  As matching arguments are found on the command line, the values shall be
    771  *  read into the arguments metadata, with the appropriate type.  The arguments and their values
    772  *  shall be removed from the list of command line arguments as they are processed.
    773  *
    774  *  @return bool:       False if any argument was encountered that is not present in arguments.
    775  */
    776 bool psArgumentParse(
    777     psMetadata *arguments,             ///< metadata container for arguments
    778     int *argc,                         ///< number or arguments
    779     char **argv                        ///< the argument list
    780 );
    781 
    782 /** Prints to stdout a guide to the command-line arguments.      */
    783 void psArgumentHelp(
    784     psMetadata *arguments              ///< metadata container for arguments
    785 );
    786734
    787735/// @}

  • trunk/psLib/test/types/Makefile.am

    r5303 r6187  
    2525        tst_psMetadata_07 \
    2626        tst_psMetadataIO  \
    27         tst_psPixels
     27        tst_psPixels \
     28        tst_psArguments
    2829
    2930
    … …  
    4748tst_psMetadataIO_SOURCES = tst_psMetadataIO.c
    4849tst_psPixels_SOURCES = tst_psPixels.c
     50tst_psArguments_SOURCES = tst_psArguments.c
    4951
    5052check_DATA = \

  • trunk/psLib/test/types/tst_psMetadata_07.c

    r6184 r6187  
    1616*  @author  David Robbins, MHPCC
    1717*
    18 *  @version $Revision: 1.16 $  $Name: not supported by cvs2svn $
    19 *  @date  $Date: 2006-01-23 20:04:31 $
     18*  @version $Revision: 1.17 $  $Name: not supported by cvs2svn $
     19*  @date  $Date: 2006-01-23 23:52:15 $
    2020*
    2121*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232static psS32 testMetaAddPtr(void);
    3333static psS32 testMetaCopy(void);
    34 static psS32 testArgument(void);
    3534
    3635testDescription tests[] = {
    … …  
    4039                              {testMetaAddPtr, 4, "Test psMetadataAddPtr", 0, false},
    4140                              {testMetaCopy, 5, "Test psMetadataCopy", 0, false},
    42                               {testArgument, 6, "Test psArgument fxns", 0, false},
    4341                              {NULL}
    4442                          };
    … …  
    276274    return 0;
    277275}
    278 
    279 psS32 testArgument(void)
    280 {
    281     char *argv[6];
    282     argv[0] = "./program";
    283     argv[1] = "-string";
    284     argv[2] = "new";
    285     argv[3] = "-float";
    286     argv[4] = "6.66";
    287     argv[5] = "-vvv";
    288     int argc = 6;
    289 
    290     int i = psArgumentGet(argc, argv, "-float");
    291     if ( i != 0 ) {
    292         if ( !psArgumentRemove(i, &argc, argv) ) {
    293             printf("\n Failed to remove float from argument list\n");
    294         }
    295     } else {
    296         printf("\nFailed to find string in argument list\n");
    297         return 1;
    298     }
    299     psArgumentRemove(i, &argc, argv);
    300     printf("\n Argument %d has been removed", i);
    301     int log = psArgumentVerbosity(&argc, argv);
    302     printf("\nLog level = %d \n", log);
    303 
    304     psMetadata *args = psMetadataAlloc();
    305     psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString");
    306     psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_S32 | PS_META_DUPLICATE_OK, "Int1", 1);
    307     psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_S32 | PS_META_DUPLICATE_OK, "Int2", 2);
    308     psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.0);
    309 
    310     printf("\nThis Should print the Argument Help list.\n\n");
    311     psArgumentHelp(args);
    312 
    313     if ( !psArgumentParse(args, &argc, argv) || argc != 1 ) {
    314         psArgumentHelp(args);
    315         psFree(args);
    316         return 2;
    317     }
    318 
    319     psMetadataPrint(args, 4);
    320 
    321     psFree(args);
    322     return 0;
    323 }
    324 

  • trunk/psLib/test/types/verified/tst_psMetadata_07.stderr

    r6184 r6187  
    5050---> TESTPOINT PASSED (psMetadata_07{Test psMetadataCopy} | tst_psMetadata_07.c)
    5151
    52 /***************************** TESTPOINT ******************************************\
    53 *             TestFile: tst_psMetadata_07.c                                        *
    54 *            TestPoint: psMetadata_07{Test psArgument fxns}                        *
    55 *             TestType: Positive                                                   *
    56 \**********************************************************************************/
    57 
    58 
    59 ---> TESTPOINT PASSED (psMetadata_07{Test psArgument fxns} | tst_psMetadata_07.c)
    60 

  • trunk/psLib/test/types/verified/tst_psMetadata_07.stdout

    r5296 r6187  
    4444---> TESTPOINT PASSED (psMetadata{Test E - psMetadataConfigWrite} | tst_psMetadata_07.c)
    4545
    46 
    47  Argument 3 has been removed
    48 Log level = 5
    49 
    50 This Should print the Argument Help list.
    51 
    52 Optional arguments, with default values:
    53     -string    (SomeString)      Test String
    54     -int       (1)               Int1
    55                (2)               Int2
    56     -float     (0.000000e+00)    Test Float
    57 Updating -string
    58     -string (Test String): new
    59     -int (Int1): 1
    60     -int (Int2): 2
    61     -float (Test Float): 0.000000
Note: See TracChangeset for help on using the changeset viewer.