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

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

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

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:128

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