lalsuite/lal/_user_input_test_8c_source.html

 /*

 * Copyright (C) 2010 Reinhard Prix

 *  Copyright (C) 2007 Jolien Creighton, Reinhard Prix

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with with program; see the file COPYING. If not, write to the

 *  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *  MA  02110-1301  USA

 */

 #include <math.h>


 #include <lal/LALVCSInfo.h>

 #include <lal/Date.h>

 #include <lal/LALString.h>


 #include <lal/UserInput.h>


 // for test print usage and help page

 int XLALUserVarPrintUsage ( FILE *file );

 int XLALUserVarPrintHelp ( FILE *file );


 typedef struct

 {

   REAL8 argNum;

   CHAR * argStr;

   BOOLEAN argBool;

   INT4 argInt;

   UINT4 argUInt;

   BOOLEAN argB2;

   CHAR *string2;        // will be read from config-file

   INT4 dummy;

   LIGOTimeGPS epochGPS;

   LIGOTimeGPS epochMJDTT;

   REAL8 longHMS;

   REAL8 longRad;

   REAL8 latDMS;

   REAL8 latRad;

   INT8 longInt;

   int argEnum;

   int argFlag;

   BOOLEAN long_help;

 } UserInput_t;


 /**

  * some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,

  * but should be enough to catch big obvious malfunctions

  */

 int

 main(int argc, char *argv[])

 {


   const char *argv_in[] = {

     "progname",

     "--argNum=1",

     "--argStr=xyz",

     "--argBool=true",

     "-a", "-1",

     "-A", "7",

     "-b",

     "--argEnum=enum2",

     "--argFlag=flagA,flagC",

     "@" TEST_DATA_DIR "ConfigFileSample.cfg"

   };


   const int my_argc = XLAL_NUM_ELEM( argv_in );

   char **my_argv = XLALCalloc ( my_argc, sizeof(char*) );

   for ( int i=0; i < my_argc; i ++ )

     {

       my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);

       strcpy ( my_argv[i], argv_in[i] );

     }


   /* ---------- Register all test user-variables ---------- */

   UserInput_t XLAL_INIT_DECL(my_uvars);

   UserInput_t *uvar = &my_uvars;

   uvar->string2 = XLALStringDuplicate ( "this is the default value");

   uvar->argEnum = 0;

   uvar->argFlag = 0;


   const UserChoices enumData = { { -1, "noenum" }, { 1, "enum1" }, { 2, "enum2" }, { 2, "enumB" }, { 0, "enum0" } };

   const UserChoices flagData = { { 0, "none" }, { -1, "noflag" }, { 1, "flagA" }, { 2, "flagB" }, { 4, "flagC" }, { 5, "flagAC" } };


   lalUserVarHelpBrief = "brief description";

   lalUserVarHelpDescription =

     "This is a longer description of the program. This is a longer description of the program. This is a longer description of the program."

     "This is a longer description of the program. This is a longer description of the program. This is a longer description of the program."

     "This is a longer description of the program. This is a longer description of the program. This is a longer description of the program."

     "\n"

     "This is a longer description of the program. This is a longer description of the program. This is a longer description of the program."

     "This is a longer description of the program. This is a longer description of the program. This is a longer description of the program.";


   XLAL_CHECK ( XLALRegisterUvarMember( argNum, REAL8, 0, REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( argStr, STRING, 0, REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( argBool, BOOLEAN, 0, REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( argInt, INT4, 'a', REQUIRED, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( argUInt, UINT4, 'A', REQUIRED, "Testing UINT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );


   lalUserVarHelpOptionSubsection = "More Options";

   XLAL_CHECK ( XLALRegisterUvarMember( dummy,  INT4, 'c', OPTIONAL, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( argB2, BOOLEAN, 'b', REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( string2, STRING, 0, REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( epochGPS, EPOCH, 0, REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( epochMJDTT, EPOCH, 0, REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );


   lalUserVarHelpOptionSubsection = "Here's Some More Options";

   XLAL_CHECK ( XLALRegisterUvarMember( longHMS, RAJ, 0, REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( longRad, RAJ, 0, REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( latDMS, DECJ, 0, REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( latRad, DECJ, 0, REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( longInt, INT8, 0, REQUIRED, "Testing INT8 argument") == XLAL_SUCCESS, XLAL_EFUNC );


   lalUserVarHelpOptionSubsection = "And Hey Look There's More Options Over Here";

   XLAL_CHECK ( XLALRegisterUvarAuxDataMember( argEnum, UserEnum, &enumData, 0, REQUIRED, "Testing user enumeration") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarAuxDataMember( argFlag, UserFlag, &flagData, 0, REQUIRED, "Testing user bitflag") == XLAL_SUCCESS, XLAL_EFUNC );

   XLAL_CHECK ( XLALRegisterUvarMember( long_help, BOOLEAN, 0, NODEFAULT,

                                        "This option is here to test the help page wrapping of long strings. "

                                        "This option is here to test the help page wrapping of long strings. "

                                        "This option is here to test the help page wrapping of long strings. "

                                        "This option is here to test the help page wrapping of long strings. "

                                        "This option is here to test the help page wrapping of long strings. "

                                        "\n"

                                        "This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"

                                        "This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"

                                        "This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces."

                  ) == XLAL_SUCCESS, XLAL_EFUNC );


   /* ---------- now read all input from commandline and config-file ---------- */

   BOOLEAN should_exit = 0;

   if ( argc > 1 ) {

     /* parse actual command-line arguments: this is only useful for debugging and testing, never used by 'make check' */

     XLAL_CHECK ( XLALUserVarReadAllInput ( &should_exit, argc, argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );

     if ( should_exit ) {

       return EXIT_FAILURE;

     }

   } else {

     /* parse constructed command-line arguments: used by 'make check' */

     XLAL_CHECK ( XLALUserVarReadAllInput ( &should_exit, my_argc, my_argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );

     XLAL_CHECK ( should_exit == 0, XLAL_EFUNC );

   }


   /* ---------- test print usage and help page */

   printf( "=== Begin usage string ===\n" );

   fflush( stdout );

   XLALUserVarPrintUsage( stdout );

   printf( "--- End usage string ---\n" );

   printf( "=== Begin help page ===\n" );

   fflush( stdout );

   XLALUserVarPrintHelp( stdout );

   printf( "--- End help page ---\n" );

   fflush( stdout );


   /* ---------- test log-generation */

   printf( "=== Begin log generation test ===\n" );

   for ( int i = UVAR_LOGFMT_RAWFORM; i < UVAR_LOGFMT_LAST; ++i ) {

     CHAR *logstr;

     XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( i )) != NULL, XLAL_EFUNC );

     printf( "Log format #%i: >>>%s<<<\n", i, logstr );

     XLALFree ( logstr );

   }

   printf( "--- End log generation test ---\n" );


   /* ---------- test values were read in correctly ---------- */

   XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );

   XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );

   XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );

   XLAL_CHECK ( uvar->argInt == -1, XLAL_EFAILED, "Failed to read in argInt\n" );

   XLAL_CHECK ( uvar->argUInt == 7, XLAL_EFAILED, "Failed to read in argUInt\n" );

   XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );

   XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );

   XLAL_CHECK ( uvar->argEnum == 2, XLAL_EFAILED, "Failed to read in argEnum\n" );

   XLAL_CHECK ( uvar->argFlag == 5, XLAL_EFAILED, "Failed to read in argFlag\n" );


   char buf1[256], buf2[256];

   XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",

                XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );


   REAL8 diff, tol = 3e-15;

   XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > %g\n", uvar->longHMS, uvar->longRad, diff, tol );

   XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > %g\n", uvar->latDMS, uvar->latRad, diff, tol );


   XLAL_CHECK ( uvar->longInt == 4294967294, XLAL_EFAILED, "Failed to read an INT8: longInt = %" LAL_INT8_FORMAT " != 4294967294", uvar->longInt );


   /* ----- cleanup ---------- */

   XLALDestroyUserVars();

   for ( int i=0; i < my_argc; i ++ ) {

     XLALFree ( my_argv[i] );

   }

   XLALFree ( my_argv );


   LALCheckMemoryLeaks();


   return XLAL_SUCCESS;


 } // main()

LALCheckMemoryLeaks
void LALCheckMemoryLeaks(void)
Definition: LALMalloc.c:784

lalVCSInfoList
const LALVCSInfoList lalVCSInfoList
NULL-terminated list of VCS and build information for LAL and its dependencies

STRING
#define STRING(a)
Definition: PrintVector.c:12

main
int main(int argc, char *argv[])
some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,...
Definition: UserInputTest.c:59

XLALUserVarPrintHelp
int XLALUserVarPrintHelp(FILE *file)
Print help page.
Definition: UserInput.c:875

XLALUserVarPrintUsage
int XLALUserVarPrintUsage(FILE *file)
Print a one-line usage string.
Definition: UserInput.c:729

XLALGPSToStr
char * XLALGPSToStr(char *, const LIGOTimeGPS *t)
Return a string containing the ASCII base 10 representation of a LIGOTimeGPS.
Definition: StrToGPS.c:274

BOOLEAN
unsigned char BOOLEAN
Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details.
Definition: LALAtomicDatatypes.h:39

XLAL_NUM_ELEM
#define XLAL_NUM_ELEM(x)
MACRO which gives the number of elements in a fixed-size array.
Definition: LALAtomicDatatypes.h:72

REAL8
double REAL8
Double precision real floating-point number (8 bytes).
Definition: LALAtomicDatatypes.h:103

XLAL_INIT_DECL
#define XLAL_INIT_DECL(var,...)
C99 MACRO to declare and zero-initialize a variable, use as "type XLAL_INIT_DECL(var);".
Definition: LALAtomicDatatypes.h:69

INT8
int64_t INT8
Eight-byte signed integer; on some platforms this is equivalent to long int instead.
Definition: LALAtomicDatatypes.h:61

CHAR
char CHAR
One-byte signed integer, see Headers LAL(Atomic)Datatypes.h for more details.
Definition: LALAtomicDatatypes.h:37

UINT4
uint32_t UINT4
Four-byte unsigned integer.
Definition: LALAtomicDatatypes.h:59

INT4
int32_t INT4
Four-byte signed integer.
Definition: LALAtomicDatatypes.h:57

XLALCalloc
#define XLALCalloc(m, n)
Definition: LALMalloc.h:45

XLALFree
#define XLALFree(p)
Definition: LALMalloc.h:47

LAL_INT8_FORMAT
#define LAL_INT8_FORMAT
Definition: LALStdio.h:128

XLALStringDuplicate
char * XLALStringDuplicate(const char *s)
Like strdup but uses LAL allocation routines (free with LALFree).
Definition: LALString.c:89

lalUserVarHelpOptionSubsection
const char * lalUserVarHelpOptionSubsection
An optional subsection heading under OPTIONS, under which all subsequently-defined user variables are...
Definition: UserInput.c:258

lalUserVarHelpBrief
const char * lalUserVarHelpBrief
An optional brief description of the program, printed after its name as part of the help page.
Definition: UserInput.c:248

XLALUserVarGetLog
CHAR * XLALUserVarGetLog(UserVarLogFormat format)
Return a log-string representing the complete user-input.
Definition: UserInput.c:1228

XLALUserVarReadAllInput
int XLALUserVarReadAllInput(BOOLEAN *should_exit, int argc, char *argv[], const LALVCSInfoList vcs_list)
Put all the pieces together, and basically does everything: print help (if requested),...
Definition: UserInput.c:1064

XLALDestroyUserVars
void XLALDestroyUserVars(void)
Free all memory associated with user-variable linked list.
Definition: UserInput.c:349

XLALRegisterUvarMember
#define XLALRegisterUvarMember(name, type, option, category,...)
Shortcut macro for registering new user variables, which are accessed via the struct-pointer '*uvar'.
Definition: UserInput.h:157

lalUserVarHelpDescription
const char * lalUserVarHelpDescription
An optional longer description of the program, printed in its own section as part of the help page.
Definition: UserInput.c:253

XLALRegisterUvarAuxDataMember
#define XLALRegisterUvarAuxDataMember(name, type, cdata, option, category,...)
Shortcut macro for registering new user variables, which are accessed via the struct-pointer '*uvar',...
Definition: UserInput.h:164

UVAR_LOGFMT_RAWFORM
@ UVAR_LOGFMT_RAWFORM
return UserVars in a raw format suitable for further parsing
Definition: UserInput.h:202

UVAR_LOGFMT_LAST
@ UVAR_LOGFMT_LAST
Definition: UserInput.h:206

XLAL_CHECK
#define XLAL_CHECK(assertion,...)
Macro to test an assertion and invoke a failure if it is not true in a function that returns an integ...
Definition: XLALError.h:810

XLAL_SUCCESS
@ XLAL_SUCCESS
Success return value (not an error number)
Definition: XLALError.h:401

XLAL_EFUNC
@ XLAL_EFUNC
Internal function call failed bit: "or" this with existing error number.
Definition: XLALError.h:462

XLAL_EFAILED
@ XLAL_EFAILED
Generic failure.
Definition: XLALError.h:418

XLALGPSCmp
int XLALGPSCmp(const LIGOTimeGPS *t0, const LIGOTimeGPS *t1)
Compares two GPS times.
Definition: XLALTime.c:174

lal_path2cache.file
file
Definition: lal_path2cache.py:127

LIGOTimeGPS
Epoch relative to GPS epoch, see LIGOTimeGPS type for more details.
Definition: LALDatatypes.h:458

UserChoices
Possible choices the user may select for an enumeration or bitflag.
Definition: UserInputParse.h:79

UserInput_t
Definition: UserInputTest.c:33

UserInput_t::latRad
REAL8 latRad
Definition: UserInputTest.c:47

UserInput_t::argEnum
int argEnum
Definition: UserInputTest.c:49

UserInput_t::argNum
REAL8 argNum
Definition: UserInputTest.c:34

UserInput_t::dummy
INT4 dummy
Definition: UserInputTest.c:41

UserInput_t::argInt
INT4 argInt
Definition: UserInputTest.c:37

UserInput_t::argB2
BOOLEAN argB2
Definition: UserInputTest.c:39

UserInput_t::long_help
BOOLEAN long_help
Definition: UserInputTest.c:51

UserInput_t::argFlag
int argFlag
Definition: UserInputTest.c:50

UserInput_t::argBool
BOOLEAN argBool
Definition: UserInputTest.c:36

UserInput_t::string2
CHAR * string2
Definition: UserInputTest.c:40

UserInput_t::epochGPS
LIGOTimeGPS epochGPS
Definition: UserInputTest.c:42

UserInput_t::latDMS
REAL8 latDMS
Definition: UserInputTest.c:46

UserInput_t::longInt
INT8 longInt
Definition: UserInputTest.c:48

UserInput_t::epochMJDTT
LIGOTimeGPS epochMJDTT
Definition: UserInputTest.c:43

UserInput_t::longHMS
REAL8 longHMS
Definition: UserInputTest.c:44

UserInput_t::argStr
CHAR * argStr
Definition: UserInputTest.c:35

UserInput_t::longRad
REAL8 longRad
Definition: UserInputTest.c:45

UserInput_t::argUInt
UINT4 argUInt
Definition: UserInputTest.c:38