IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8805


Ignore:
Timestamp:
Sep 12, 2006, 4:20:15 PM (20 years ago)
Author:
drobbin
Message:

Added testing for Arguments. Edited src file minimally. coverage at 100%. Edited ItemCompare to complete 100% coverage.

Location:
trunk/psLib
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

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

    r8627 r8805  
    77 *  @author David Robbins, MHPCC
    88 *
    9  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-08-26 04:34:28 $
     9 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-09-13 02:20:15 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psLogMsg.h"
    2525#include "psTrace.h"
     26#include "psAssert.h"
    2627
    2728#define NUM_SPACES 4   // Number of spaces between
    2829
    2930// Set verbosity level
    30 int psArgumentVerbosity(int *argc, char **argv)
     31int psArgumentVerbosity(int *argc,
     32                        char **argv)
    3133{
    3234    int logLevel = 2;   // Default log level
     35    psLogSetLevel(logLevel);
     36    PS_ASSERT_PTR_NON_NULL(argv, 2);
     37    PS_ASSERT_PTR_NON_NULL(argc, 2);
    3338    int argnum = 0;   // Argument number
    3439
    … …  
    6368        if ( (*argc < argnum + 3) ) {
    6469            psError(PS_ERR_IO, true, "-trace switch specified without facility and level.");
     70            return logLevel;
    6571        }
    6672        psArgumentRemove(argnum, argc, argv);
    … …  
    7177    if ((argnum = psArgumentGet(*argc, argv, "-trace-levels"))) {
    7278        psTracePrintLevels();
    73         exit(2);
     79        //        exit(2);
     80        return logLevel;
    7481    }
    7582
    … …  
    7885
    7986// Find the location of the specified argument
    80 int psArgumentGet(int argc, char **argv, const char *arg)
    81 {
     87int psArgumentGet(int argc,
     88                  char **argv,
     89                  const char *arg)
     90{
     91    PS_ASSERT_PTR_NON_NULL(argv, 0);
     92    PS_ASSERT_PTR_NON_NULL(arg, 0);
     93    if (strlen(arg) == 0)
     94        return 0;
    8295    for (int i = 1; i < argc; i++) {
    8396        if (!strcmp(argv[i], arg))
    … …  
    89102
    90103// Remove the specified argument (by location)
    91 bool psArgumentRemove(int argnum, int *argc, char **argv)
    92 {
     104bool psArgumentRemove(int argnum,
     105                      int *argc,
     106                      char **argv)
     107{
     108    PS_ASSERT_PTR_NON_NULL(argv, false);
     109    PS_ASSERT_PTR_NON_NULL(argc, false);
    93110    if (argnum > 0) {
    94111        (*argc)--;
    … …  
    148165                     char **argv)
    149166{
     167    PS_ASSERT_PTR_NON_NULL(arguments, false);
     168    PS_ASSERT_PTR_NON_NULL(argv, false);
     169    PS_ASSERT_PTR_NON_NULL(argc, false);
     170    if (*argc < 1)
     171        return false;
    150172    // We need to do a bit of mucking around in order to preserve the arguments metadata until the last
    151173    // minute --- if there is a bad argument, we need to return the old "arguments", since they contain
    … …  
    174196                    }
    175197
    176                     psMetadataIterator *paramsIter = psMetadataIteratorAlloc(params, PS_LIST_HEAD, NULL);// Iter
     198                    psMetadataIterator *paramsIter = psMetadataIteratorAlloc(params,
     199                                                     PS_LIST_HEAD, NULL);// Iter
    177200                    psMetadataItem *param = NULL; // Parameter from iteration
    178201                    while ((param = psMetadataGetAndIncrement(paramsIter))) {
    … …  
    252275        LENGTH_CASE(U16);
    253276        LENGTH_CASE(U32);
     277        LENGTH_CASE(U64);
    254278        LENGTH_CASE(S8);
    255279        LENGTH_CASE(S16);
    256280        LENGTH_CASE(S32);
     281        LENGTH_CASE(S64);
    257282    case PS_DATA_F32:
    258283        return arg->data.F32 >= 0 ? 12 : 13; // -d.dddddde?dd
    … …  
    264289        return arg->data.V ? strlen(arg->data.V) : 0;
    265290    default:
    266         psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type);
     291        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     292                "Argument type (%x) is not supported.\n", arg->type);
     293        return 0;
     294        //        psAbort(__func__, "Argument type (%x) is not supported.\n", arg->type);
    267295    }
    268296
    … …  
    279307static void printValueComment(psMetadataItem *item, // Argument item for which to print
    280308                              const char *comment, // Comment to print
    281                               unsigned int numSpaces // Number of spaces
    282                              )
     309                              unsigned int numSpaces) // Number of spaces
     310
    283311{
    284312    int valueLength = 0;                // Length of the value portion
    … …  
    287315        // Print the value
    288316        switch (item->type) {
    289             PRINT_CASE(U8,"%d");
    290             PRINT_CASE(U16,"%d");
    291             PRINT_CASE(U32,"%d");
     317            PRINT_CASE(U8,"%u");
     318            PRINT_CASE(U16,"%u");
     319            PRINT_CASE(U32,"%u");
     320            PRINT_CASE(U64,"%lu");
    292321            PRINT_CASE(S8,"%d");
    293322            PRINT_CASE(S16,"%d");
    294323            PRINT_CASE(S32,"%d");
     324            PRINT_CASE(S64,"%ld");
    295325            PRINT_CASE(F32,"%.6e");
    296326            PRINT_CASE(F64,"%.6e");
    … …  
    308338            break;
    309339        default:
    310             psAbort(__func__, "Argument type (%x) for %s is not supported.\n", item->type, item->name);
     340            //            psAbort(__func__, "Argument type (%x) for %s is not supported.\n",
     341            //                    item->type, item->name);
     342            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     343                    "Argument type (%x) for %s is not supported.\n", item->type, item->name);
    311344        }
    312345        valueLength = argLength(item);
    … …  
    331364static void maxLength(int *maxName,     // Maximum length of the name
    332365                      int *maxValue,    // Maximum length of the value
    333                       psMetadata *md    // Metadata for which to check the length
    334                      )
     366                      psMetadata *md)    // Metadata for which to check the length
     367
    335368{
    336369    psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); // Iterator
    337370    psMetadataItem *item = NULL;        // Item from iteration
    338     while ((item = psMetadataGetAndIncrement(iter))) {
     371    while ((item = psMetadataGetAndIncrement(iter)))
     372    {
    339373        if (item->type == PS_DATA_METADATA) {
    340374            maxLength(maxName, maxValue, item->data.V);
    … …  
    357391void psArgumentHelp(psMetadata *arguments)
    358392{
     393    if (arguments == NULL)
     394        return;
    359395    printf("Optional arguments, with default values:\n");
    360396    int maxName = 4;   // Maximum length of a name
    … …  
    384420        psMetadataItem *multiCheck = psMetadataLookup(arguments, argItem->name); // Item to check for MULTI
    385421        if (multiCheck->type == PS_DATA_METADATA_MULTI) {
    386             printValueComment(NULL, argItem->comment, maxValue + NUM_SPACES);
     422            bool first = true;          // Is this the first one?
     423            psListIterator* iter = psListIteratorAlloc(multiCheck->data.list,PS_LIST_HEAD,true);
     424            psMetadataItem* listItem;
     425            int count = 0;
     426            //            while ((listItem=(psMetadataItem*)psListGetAndIncrement(iter)) != NULL) {
     427            while ((listItem=(psMetadataItem*)psListGetAndIncrement(iter)) != NULL) {
     428                //                for (int i = 0; i < NUM_SPACES; i++) {
     429                //                    printf(" ");
     430                //                }
     431                //                printf("%s", listItem->name);
     432                //                int position = strlen(listItem->name); // Number of spaces in
     433                //                for (int i = position; i < maxName + NUM_SPACES; i++) {
     434                //                    printf(" ");
     435                //                }
     436                if (!first) {
     437                    for (int i = 0; i < maxName + 2*NUM_SPACES; i++) {
     438                        printf(" ");
     439                    }
     440                }
     441                printValueComment(listItem, listItem->comment, maxValue + NUM_SPACES);
     442                first = false;
     443                count++;
     444                //                continue;
     445            }
     446            psFree(iter);
     447            while (count > 1) {
     448                argItem = psMetadataGetAndIncrement(argIter);
     449                count--;
     450            }
    387451            continue;
    388452        }
    … …  
    416480// we have log levels 1 (Error), 2 (Warning), 3 (Info), 4 (Details), 5 (Minutiae)
    417481// 2 = default, -v = 3, -vv = 4, -vvv = 5
    418 psS32 psLogArguments (int *argc, char **argv)
    419 {
    420 
     482psS32 psLogArguments (int *argc,
     483                      char **argv)
     484{
    421485    int N, level;
    422486
    … …  
    424488    level = 2;
    425489
     490    psLogSetLevel (level);
     491    PS_ASSERT_PTR_NON_NULL(argv, 2);
     492    PS_ASSERT_PTR_NON_NULL(argc, 2);
    426493    // set in order, so that -vvv overrides -vv overrides -v
    427494    if ((N = psArgumentGet (*argc, argv, "-v"))) {
    … …  
    440507    if ((N = psArgumentGet (*argc, argv, "-logfmt"))) {
    441508        if (*argc < N + 2) {
    442             psAbort ("psLogArguments", "USAGE: -logfmt (format)");
    443         }
    444         psArgumentRemove (N, argc, argv);
    445         psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid
    446         psArgumentRemove (N, argc, argv);
     509            //            psAbort ("psLogArguments", "USAGE: -logfmt (format)");
     510            psError(PS_ERR_IO, true, "-logfmt switch specified without a format.");
     511        } else {
     512            psArgumentRemove (N, argc, argv);
     513            psLogSetFormat (argv[N]); // XXX EAM : this function should return an error if the log format is invalid
     514            psArgumentRemove (N, argc, argv);
     515        }
    447516    }
    448517
    … …  
    453522
    454523// set trace levels by facility
    455 psS32 psTraceArguments (int *argc, char **argv)
    456 {
    457 
     524psS32 psTraceArguments (int *argc,
     525                        char **argv)
     526{
    458527    int N;
     528    PS_ASSERT_PTR_NON_NULL(argv, 0);
     529    PS_ASSERT_PTR_NON_NULL(argc, 0);
    459530
    460531    // argument format is: -trace (facil) (level)
    461532    while ((N = psArgumentGet (*argc, argv, "-trace"))) {
    462533        if (*argc < N + 3) {
    463             psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)");
     534            //            psAbort ("psTraceArguments", "USAGE: -trace (facility) (level)");
     535            psError(PS_ERR_IO, true, "-trace switch specified without facility and level.");
     536            return 0;
    464537        }
    465538        psArgumentRemove (N, argc, argv);
    … …  
    470543    if ((N = psArgumentGet (*argc, argv, "-trace-levels"))) {
    471544        psTracePrintLevels ();
    472         exit (2);
     545        //        exit (2);
     546        return 0;
    473547    }
    474548    return (TRUE);

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

    r8797 r8805  
    2323        tap_psMetadata_manip   \
    2424        tap_psMetadata_polynomials \
    25         tap_psArray_all
     25        tap_psArray_all \
     26        tap_psArguments_all
    2627
    2728check_DATA = \

  • trunk/psLib/test/types/execute_tap

    r8786 r8805  
    1111./tap_psMetadata_printing
    1212./tap_psMetadata_polynomials
     13./tap_psArguments_all

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

    r8731 r8805  
    1111    psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true)
    1212                           ;
    13     plan_tests(21);
     13    plan_tests(22);
    1414
    1515    diag("psMetadataItemCompare() tests");
    … …  
    1818    {
    1919        ok( !psMetadataItemCompare(compare, item),
    20             "return false for NULL compare input." );
     20            "psMetadataItemCompare:      return false for NULL compare input." );
    2121    }
    2222    //Return false for NULL template psMetadataItem
    2323    {
    2424        ok( !psMetadataItemCompare(item, template),
    25             "return false for NULL template input." )
     25            "psMetadataItemCompare:      return false for NULL template input." )
    2626        ;
    2727    }
    … …  
    3535    {
    3636        ok( !psMetadataItemCompare(template, item),
    37             "return false for input with different names." )
     37            "psMetadataItemCompare:      return false for input with different names.")
    3838        ;
    3939    }
    … …  
    4242    {
    4343        ok( psMetadataItemCompare(itemCopy, item),
    44             "return true for comparison of identical psMetadataItem's." );
     44            "psMetadataItemCompare:      return true for comparison of identical psMetadataItem's.");
    4545    }
    4646
    … …  
    4848    {
    4949        ok( psMetadataItemCompare(compare, item),
    50             "return true for valid compare of different type." );
     50            "psMetadataItemCompare:      return true for valid compare of different type.");
    5151    }
    5252
    … …  
    5656    {
    5757        ok( psMetadataItemCompare(compare, item),
    58             "return false for comparison of F64 to bool." );
     58            "psMetadataItemCompare:      return false for comparison of F64 to bool." );
    5959    }
    6060    //Return true for comparing F64 with Bool
    6161    {
    6262        ok( psMetadataItemCompare(item, compare),
    63             "return false for comparison of bool to F64." );
     63            "psMetadataItemCompare:      return false for comparison of bool to F64." );
    6464    }
    6565
    … …  
    7373    {
    7474        ok( psMetadataItemCompare(compare, template),
    75             "return true for comparison of S32 to F32." )
     75            "psMetadataItemCompare:      return true for comparison of S32 to F32." )
    7676        ;
    7777    }
    … …  
    7979    {
    8080        ok( psMetadataItemCompare(template, compare),
    81             "return true for comparison of F32 to S32." )
     81            "psMetadataItemCompare:      return true for comparison of F32 to S32." )
    8282        ;
    8383    }
    … …  
    9292    {
    9393        ok( psMetadataItemCompare(compare, template),
    94             "return true for comparison of S16 to U32." )
     94            "psMetadataItemCompare:     return true for comparison of S16 to U32." )
    9595        ;
    9696    }
    … …  
    9898    {
    9999        ok( psMetadataItemCompare(template, compare),
    100             "return true for comparison of U32 to S16." )
     100            "psMetadataItemCompare:     return true for comparison of U32 to S16." )
    101101        ;
    102102    }
    … …  
    111111    {
    112112        ok( psMetadataItemCompare(compare, template),
    113             "return true for comparison of U8 to U16." )
     113            "psMetadataItemCompare:     return true for comparison of U8 to U16." )
    114114        ;
    115115    }
    … …  
    117117    {
    118118        ok( psMetadataItemCompare(template, compare),
    119             "return true for comparison of U16 to U8." )
     119            "psMetadataItemCompare:     return true for comparison of U16 to U8." )
    120120        ;
    121121    }
    … …  
    126126    {
    127127        ok( psMetadataItemCompare(compare, template),
    128             "return true for comparison of U8 to S8." )
     128            "psMetadataItemCompare:     return true for comparison of U8 to S8." )
    129129        ;
    130130    }
    … …  
    132132    {
    133133        ok( psMetadataItemCompare(template, compare),
    134             "return true for comparison of S8 to U8." )
     134            "psMetadataItemCompare:     return true for comparison of S8 to U8." )
    135135        ;
    136136    }
    … …  
    141141    {
    142142        ok( !psMetadataItemCompare(compare, template),
    143             "return false for comparison of U8 to S64*.  *not yet implemented" )
     143            "psMetadataItemCompare:     return false for comparison of U8 to S64*.  "
     144            "*not yet implemented" )
    144145        ;
    145146    }
    … …  
    147148    {
    148149        ok( !psMetadataItemCompare(template, compare),
    149             "return false for comparison of S64* to U8.  *not yet implemented" )
     150            "psMetadataItemCompare:     return false for comparison of S64* to U8.  "
     151            "*not yet implemented" )
    150152        ;
    151153    }
    … …  
    160162    {
    161163        ok( !psMetadataItemCompare(compare, template),
    162             "return false for comparison of different psString's." )
     164            "psMetadataItemCompare:     return false for comparison of different psString's.")
    163165        ;
    164166    }
    … …  
    171173    {
    172174        ok( psMetadataItemCompare(compare, template),
    173             "return true for comparison of identical psString's." )
     175            "psMetadataItemCompare:     return true for comparison of identical psString's.")
    174176        ;
    175177    }
    … …  
    182184    {
    183185        ok( !psMetadataItemCompare(compare, template),
    184             "return false for comparison of psString with bool." )
     186            "psMetadataItemCompare:     return false for comparison of psString with bool.")
     187        ;
     188    }
     189    //Return false for comparing bool with string
     190    psFree(template)
     191    ;
     192    template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false)
     193               ;
     194    {
     195        ok( !psMetadataItemCompare(template, compare),
     196            "psMetadataItemCompare:     return false for comparison of psString with bool.")
    185197        ;
    186198    }

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

    r7448 r8805  
    55*  @author  David Robbins, MHPCC
    66*
    7 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    8 *  @date  $Date: 2006-06-09 01:25:42 $
     7*  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     8*  @date  $Date: 2006-09-13 02:20:15 $
    99*
    1010*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1212*/
    1313
    14 #include "psTest.h"
    15 #include "pslib_strict.h"
     14#include "pslib.h"
    1615
    1716static psS32 testArgument(void);
    18 
     17/*
    1918testDescription tests[] = {
    2019                              {testArgument, 666, "Test psArgument fxns", 0, false},
    2120                              {NULL}
    2221                          };
    23 
     22*/
    2423int main(int argc, char* argv[])
    2524{
    2625    psLogSetLevel( PS_LOG_INFO );
    27     if( !runTestSuite(stderr,"psArguments",tests,argc,argv)) {
    28         return 1;
    29     }
     26    testArgument();
     27    //    if( !runTestSuite(stderr,"psArguments",tests,argc,argv)) {
     28    //        return 1;
     29    //    }
    3030    return 0;
    3131}
Note: See TracChangeset for help on using the changeset viewer.