LAL  7.5.0.1-89842e6
UserInputParseTest.c
Go to the documentation of this file.
1 //
2 // Copyright (C) 2016 Karl Wette
3 // Copyright (C) 2015 Reinhard Prix
4 //
5 // This program is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation; either version 2 of the License, or
8 // (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with with program; see the file COPYING. If not, write to the
17 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18 // MA 02110-1301 USA
19 //
20 
21 // Tests of the unit conversion functions in the UserInputParser.[ch] module
22 
23 #include <stdio.h>
24 #include <math.h>
25 #include <string.h>
26 
27 #include <lal/LALStdio.h>
28 #include <lal/Date.h>
29 #include <lal/XLALError.h>
30 #include <lal/LALDebugLevel.h>
31 #include <lal/LALMalloc.h>
32 #include <lal/LALConstants.h>
33 #include <lal/StringVector.h>
34 #include <lal/AVFactories.h>
35 #include <lal/UserInputPrint.h>
36 #include <lal/UserInputParse.h>
37 
38 // ---------- local prototypes ----------
39 int test_ParseStringValue ( void );
40 int test_ParseStringVector(void);
41 int test_ParseREAL8Vector(void);
42 
43 // ==================== function definitions ====================
44 int main(void)
45 {
46 
47  // ---------- test XLAL_IDX2BIT()/XLAL_BIT2IDX() macros
48  for ( int i = 0; i < 64; ++i ) {
49  const unsigned long j = XLAL_IDX2BIT( i );
50  const int k = XLAL_BIT2IDX( j );
51  XLAL_CHECK_MAIN( i == k, XLAL_EFAILED, "XLAL_IDX2BIT()/XLAL_BIT2IDX() failed: %i -> %lu -> %i\n", i, j, k );
52  }
53 
54  // ---------- test various string-value parser functions ----------
55  XLAL_CHECK_MAIN ( test_ParseStringValue() == XLAL_SUCCESS, XLAL_EFUNC );
56 
57  XLAL_CHECK_MAIN ( test_ParseStringVector() == XLAL_SUCCESS, XLAL_EFUNC );
58 
59  XLAL_CHECK_MAIN ( test_ParseREAL8Vector() == XLAL_SUCCESS, XLAL_EFUNC );
60 
61  // check for memory leaks
62  LALCheckMemoryLeaks();
63 
64  return EXIT_SUCCESS;
65 
66 } // main()
67 
68 ///
69 /// test various string-value parser functions:
70 /// XLALParseStringValueAsINT8(), XLALParseStringValueAsINT4(), XLALParseStringValueAsREAL8(),
71 /// XLALParseStringValueAsINT4PlusFrac()
72 ///
73 int
74 test_ParseStringValue ( void )
75 {
76  const char *valString;
77  int errnum;
78 
79  // ---------- XLALParseStringValueAsINT8() ----------
80  INT8 valINT8, valINT8Ref;
81  valString = "9223372036854775807"; // LAL_INT8_MAX
82  valINT8Ref = 9223372036854775807;
83  XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
84  XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 );
85 
86  valString = "4294967294"; // 2 * LAL_INT4_MAX
87  valINT8Ref = 4294967294;
88  XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
89  XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 );
90 
91  valString = "-4294967294"; // -2 * LAL_INT4_MAX
92  valINT8Ref = -4294967294;
93  XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
94  XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 );
95 
96  // this one needs to fail!
97  valString = "18446744073709551616"; // 2 * LAL_INT8_MAX
98  XLAL_TRY_SILENT( XLALParseStringValueAsINT8 ( &valINT8, valString ), errnum );
99  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsINT8() failed to catch out-of-range conversion\n" );
100 
101  // ---------- XLALParseStringValueAsINT4() ----------
102  INT4 valINT4, valINT4Ref;
103  valString = "2147483647"; // LAL_INT4_MAX
104  valINT4Ref = 2147483647;
105  XLAL_CHECK ( XLALParseStringValueAsINT4 ( &valINT4, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
106  XLAL_CHECK ( valINT4 == valINT4Ref, XLAL_ETOL, "XLALParseStringValueAsINT4(%s) failed, return = %d\n", valString, valINT4 );
107 
108  valString = "-1000000";
109  valINT4Ref = -1000000;
110  XLAL_CHECK ( XLALParseStringValueAsINT4 ( &valINT4, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
111  XLAL_CHECK ( valINT4 == valINT4Ref, XLAL_ETOL, "XLALParseStringValueAsINT4(%s) failed, return = %d\n", valString, valINT4 );
112 
113  // this one needs to fail!
114  valString = "4294967294"; // 2 * LAL_INT4_MAX
115  XLAL_TRY_SILENT( XLALParseStringValueAsINT4 ( &valINT4, valString ), errnum );
116  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsINT4() failed to catch out-of-range conversion\n" );
117 
118  // ---------- XLALParseStringValueAsUINT8() ----------
119  UINT8 valUINT8, valUINT8Ref;
120  valString = "18446744073709551615"; // LAL_UINT8_MAX
121  valUINT8Ref = LAL_UINT8_C(18446744073709551615);
122  XLAL_CHECK ( XLALParseStringValueAsUINT8 ( &valUINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
123  XLAL_CHECK ( valUINT8 == valUINT8Ref, XLAL_ETOL, "XLALParseStringValueAsUINT8(%s) failed, return = %" LAL_UINT8_FORMAT "\n", valString, valUINT8 );
124 
125  valString = "4294967294"; // 2 * LAL_UINT4_MAX
126  valUINT8Ref = 4294967294;
127  XLAL_CHECK ( XLALParseStringValueAsUINT8 ( &valUINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
128  XLAL_CHECK ( valUINT8 == valUINT8Ref, XLAL_ETOL, "XLALParseStringValueAsUINT8(%s) failed, return = %" LAL_UINT8_FORMAT "\n", valString, valUINT8 );
129 
130  // this one needs to fail!
131  valString = "-4294967294"; // -2 * LAL_UINT4_MAX
132  XLAL_TRY_SILENT( XLALParseStringValueAsUINT8 ( &valUINT8, valString ), errnum );
133  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsUINT8() failed to catch out-of-range conversion\n" );
134 
135  // ---------- XLALParseStringValueAsUINT4() ----------
136  UINT4 valUINT4, valUINT4Ref;
137  valString = "4294967295"; // LAL_UINT4_MAX
138  valUINT4Ref = 4294967295;
139  XLAL_CHECK ( XLALParseStringValueAsUINT4 ( &valUINT4, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
140  XLAL_CHECK ( valUINT4 == valUINT4Ref, XLAL_ETOL, "XLALParseStringValueAsUINT4(%s) failed, return = %d\n", valString, valUINT4 );
141 
142  // this one needs to fail!
143  valString = "-1000000";
144  XLAL_TRY_SILENT( XLALParseStringValueAsUINT4 ( &valUINT4, valString ), errnum );
145  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsUINT4() failed to catch out-of-range conversion\n" );
146 
147  // ---------- XLALParseStringValueAsREAL8() ----------
148  REAL8 valREAL8, valREAL8Ref;
149  valString = "2147483647";
150  valREAL8Ref = 2147483647;
151  XLAL_CHECK ( XLALParseStringValueAsREAL8 ( &valREAL8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
152  XLAL_CHECK ( valREAL8 == valREAL8Ref, XLAL_ETOL, "XLALParseStringValueAsREAL8(%s) failed, return = %.16g\n", valString, valREAL8 );
153 
154  valString = "-1.1234e10";
155  valREAL8Ref = -1.1234e10;
156  XLAL_CHECK ( XLALParseStringValueAsREAL8 ( &valREAL8, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
157  XLAL_CHECK ( fabs ( (valREAL8 - valREAL8Ref) / valREAL8Ref ) <= LAL_REAL8_EPS, XLAL_ETOL, "XLALParseStringValueAsREAL8(%s) failed, return = %.16g\n", valString, valREAL8 );
158 
159  // ---------- XLALParseStringValueAsREAL4() ----------
160  REAL4 valREAL4, valREAL4Ref;
161  valString = "2147483647";
162  valREAL4Ref = 2147483647.0;
163  XLAL_CHECK ( XLALParseStringValueAsREAL4 ( &valREAL4, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
164  XLAL_CHECK ( valREAL4 == valREAL4Ref, XLAL_ETOL, "XLALParseStringValueAsREAL4(%s) failed, return = %.16g\n", valString, valREAL4 );
165 
166  valString = "-1.1234e10";
167  valREAL4Ref = -1.1234e10;
168  XLAL_CHECK ( XLALParseStringValueAsREAL4 ( &valREAL4, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
169  XLAL_CHECK ( fabs ( (valREAL4 - valREAL4Ref) / valREAL4Ref ) <= LAL_REAL4_EPS, XLAL_ETOL, "XLALParseStringValueAsREAL4(%s) failed, return = %.16g\n", valString, valREAL4 );
170 
171 
172  // ---------- XLALParseStringValueAsINT4PlusFrac() ----------
173  INT4 valINT, valINTRef;
174  REAL8 valFrac, valFracRef;
175 
176  valString = "123456789.12345678912345";
177  valINTRef = 123456789;
178  valFracRef = 0.12345678912345;
179  XLAL_CHECK ( XLALParseStringValueAsINT4PlusFrac ( &valINT, &valFrac, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
180  XLAL_CHECK ( (valINT == valINTRef) && (fabs( (valFrac - valFracRef) / valFracRef ) <= LAL_REAL8_EPS), XLAL_ETOL,
181  "XLALParseStringValueAsINT4PlusFrac(%s) failed, return = (%d, %.16g)\n", valString, valINT, valFrac );
182 
183  valString = "-123456789.12345678912345";
184  valINTRef = -123456789;
185  valFracRef = -0.12345678912345;
186  XLAL_CHECK ( XLALParseStringValueAsINT4PlusFrac ( &valINT, &valFrac, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
187  XLAL_CHECK ( (valINT == valINTRef) && (fabs( (valFrac - valFracRef) / valFracRef ) <= LAL_REAL8_EPS), XLAL_ETOL,
188  "XLALParseStringValueAsINT4PlusFrac(%s) failed, return = (%d, %.16g)\n", valString, valINT, valFrac );
189 
190  // ---------- XLALParseStringValueAsGPS() ----------
191  LIGOTimeGPS valGPS, valGPSRef = {987654321, 123456789 };
192 
193  valString = "987654321.123456789";
194  XLAL_CHECK ( XLALParseStringValueAsGPS ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
195  XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds );
196 
197  // ---------- XLALParseStringValueAsEPOCH() ----------
198  XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
199  XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds );
200 
201  valString = "987654321.123456789GPS";
202  XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
203  XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds );
204 
205  valString = "55675.1848646696387616MJD";
206  XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
207  XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds );
208 
209  valString = "987654321.12345";
210  valGPSRef.gpsNanoSeconds = 123450000;
211  XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
212  XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}, correct = {%d,%d}\n",
213  valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds, valGPSRef.gpsSeconds, valGPSRef.gpsNanoSeconds );
214 
215  // ---------- XLALParseStringValueAsREAL8Range() ----------
216  INT4Range int4Range, int4RangeRef;
217 
218  valString = "100";
219  int4RangeRef[0] = 100; int4RangeRef[1] = 100;
220  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
221  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
222  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
223 
224  valString = "150/5";
225  int4RangeRef[0] = 150; int4RangeRef[1] = 155;
226  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
227  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
228  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
229 
230  valString = "150/-5";
231  int4RangeRef[0] = 145; int4RangeRef[1] = 150;
232  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
233  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
234  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
235 
236  valString = "200,201";
237  int4RangeRef[0] = 200; int4RangeRef[1] = 201;
238  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
239  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
240  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
241 
242  valString = "203,202";
243  int4RangeRef[0] = 202; int4RangeRef[1] = 203;
244  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
245  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
246  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
247 
248  valString = "-203,-202";
249  int4RangeRef[0] = -203; int4RangeRef[1] = -202;
250  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
251  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
252  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
253 
254  valString = "250~5";
255  int4RangeRef[0] = 245; int4RangeRef[1] = 255;
256  XLAL_CHECK( XLALParseStringValueAsINT4Range(int4Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
257  XLAL_CHECK( int4Range[0] == int4RangeRef[0] && int4Range[1] == int4RangeRef[1] && int4Range[0] <= int4Range[1],
258  XLAL_ETOL, "XLALParseStringValueAsINT4Range(%s) failed, return = {%d,%d}\n", valString, int4Range[0], int4Range[1] );
259 
260  // ---------- XLALParseStringValueAsREAL8Range() ----------
261  REAL8Range real8Range, real8RangeRef;
262 
263  valString = "100";
264  real8RangeRef[0] = 100; real8RangeRef[1] = 100;
265  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
266  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
267  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
268 
269  valString = "150/0.5";
270  real8RangeRef[0] = 150; real8RangeRef[1] = 150.5;
271  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
272  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
273  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
274 
275  valString = "150/-0.5";
276  real8RangeRef[0] = 149.5; real8RangeRef[1] = 150;
277  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
278  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
279  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
280 
281  valString = "200,201";
282  real8RangeRef[0] = 200; real8RangeRef[1] = 201;
283  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
284  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
285  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
286 
287  valString = "203,202";
288  real8RangeRef[0] = 202; real8RangeRef[1] = 203;
289  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
290  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
291  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
292 
293  valString = "-203,-202";
294  real8RangeRef[0] = -203; real8RangeRef[1] = -202;
295  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
296  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
297  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
298 
299  valString = "250~5";
300  real8RangeRef[0] = 245; real8RangeRef[1] = 255;
301  XLAL_CHECK( XLALParseStringValueAsREAL8Range(real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC );
302  XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1],
303  XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] );
304 
305  // ---------- XLALParseStringValueAsEPOCHRange() ----------
306  LIGOTimeGPSRange gpsRange, gpsRangeRef;
307 
308  valString = "100200300.4";
309  XLALGPSSet(&gpsRangeRef[0], 100200300, 400000000); XLALGPSSet(&gpsRangeRef[1], 100200300, 400000000);
310  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
311  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
312  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
313 
314  valString = "100200300.4/800600400.2";
315  XLALGPSSet(&gpsRangeRef[0], 100200300, 400000000); XLALGPSSet(&gpsRangeRef[1], 900800700, 600000000);
316  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
317  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
318  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
319 
320  valString = "100200300.4/-800600400.2";
321  XLALGPSSet(&gpsRangeRef[0], -700400099, -800000000); XLALGPSSet(&gpsRangeRef[1], 100200300, 400000000);
322  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
323  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
324  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
325 
326  valString = "200300400.5,600700800.9";
327  XLALGPSSet(&gpsRangeRef[0], 200300400, 500000000); XLALGPSSet(&gpsRangeRef[1], 600700800, 900000000);
328  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
329  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
330  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
331 
332  valString = "600700800.9,200300400.5";
333  XLALGPSSet(&gpsRangeRef[0], 200300400, 500000000); XLALGPSSet(&gpsRangeRef[1], 600700800, 900000000);
334  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
335  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
336  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
337 
338  valString = "123456789~123456.789";
339  XLALGPSSet(&gpsRangeRef[0], 123333332, 211000000); XLALGPSSet(&gpsRangeRef[1], 123580245, 789000000);
340  XLAL_CHECK( XLALParseStringValueAsEPOCHRange(gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
341  XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL,
342  "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds );
343 
344  // ---------- XLALParseStringValueAsRAJRange() ----------
345  REAL8Range rajRange, rajRangeRef;
346 
347  valString = "0.1";
348  rajRangeRef[0] = 0.1; rajRangeRef[1] = 0.1;
349  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
350  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
351  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
352 
353  valString = "10:20:30/0.5";
354  rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = rajRangeRef[0] + 0.5;
355  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
356  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
357  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
358 
359  valString = "10:20:30/-0.5";
360  rajRangeRef[0] = 2.7074420021562036 - 0.5; rajRangeRef[1] = rajRangeRef[0] + 0.5;
361  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
362  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
363  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
364 
365  valString = "10:20:30,11:22:33";
366  rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = 2.9781862023718242;
367  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
368  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
369  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
370 
371  valString = "11:22:33,10:20:30";
372  rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = 2.9781862023718242;
373  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
374  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
375  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
376 
377  valString = "11:22:33~00:00:44.55";
378  rajRangeRef[0] = 2.9749464349478099; rajRangeRef[1] = 2.9814259697958385;
379  XLAL_CHECK( XLALParseStringValueAsRAJRange(rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
380  XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1],
381  XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] );
382 
383  // ---------- XLALParseStringValueAsDECJRange() ----------
384  REAL8Range decjRange, decjRangeRef;
385 
386  valString = "0.1";
387  decjRangeRef[0] = 0.1; decjRangeRef[1] = 0.1;
388  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
389  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
390  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
391 
392  valString = "10:20:30/0.5";
393  decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = decjRangeRef[0] + 0.5;
394  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
395  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
396  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
397 
398  valString = "10:20:30/-0.5";
399  decjRangeRef[0] = (2.7074420021562036/15) - 0.5; decjRangeRef[1] = decjRangeRef[0] + 0.5;
400  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
401  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
402  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
403 
404  valString = "10:20:30,11:22:33";
405  decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = (2.9781862023718242/15);
406  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
407  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
408  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
409 
410  valString = "11:22:33,10:20:30";
411  decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = (2.9781862023718242/15);
412  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
413  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
414  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
415 
416  valString = "11:22:33~00:00:44.55";
417  decjRangeRef[0] = (2.9749464349478099/15); decjRangeRef[1] = (2.9814259697958385/15);
418  XLAL_CHECK( XLALParseStringValueAsDECJRange(decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC );
419  XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1],
420  XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] );
421 
422  // ---------- XLALParseStringValueAsUserEnum() ----------
423  int valEnum;
424  const UserChoices enumData = { { -1, "noenum" }, { 1, "enum1" }, { 2, "enum2" }, { 2, "enumB" }, { 0, "enum0" } };
425 
426  valString = "noenum";
427  XLAL_TRY_SILENT( XLALParseStringValueAsUserEnum ( &valEnum, &enumData, valString ), errnum );
428  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsUserEnum() failed to catch invalid enumeration value\n" );
429 
430  valString = "enum0";
431  XLAL_CHECK( XLALParseStringValueAsUserEnum ( &valEnum, &enumData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
432  XLAL_CHECK( valEnum == 0, XLAL_ETOL, "XLALParseStringValueAsUserEnum(%s), failed, return = %i", valString, valEnum );
433 
434  valString = "enum1";
435  XLAL_CHECK( XLALParseStringValueAsUserEnum ( &valEnum, &enumData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
436  XLAL_CHECK( valEnum == 1, XLAL_ETOL, "XLALParseStringValueAsUserEnum(%s), failed, return = %i", valString, valEnum );
437 
438  valString = "enum2";
439  XLAL_CHECK( XLALParseStringValueAsUserEnum ( &valEnum, &enumData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
440  XLAL_CHECK( valEnum == 2, XLAL_ETOL, "XLALParseStringValueAsUserEnum(%s), failed, return = %i", valString, valEnum );
441 
442  valString = "enumb";
443  XLAL_CHECK( XLALParseStringValueAsUserEnum ( &valEnum, &enumData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
444  XLAL_CHECK( valEnum == 2, XLAL_ETOL, "XLALParseStringValueAsUserEnum(%s), failed, return = %i", valString, valEnum );
445 
446  // ---------- XLALParseStringValueAsUserFlag() ----------
447  int valFlag;
448  const UserChoices flagData = { { 0, "none" }, { -1, "noflag" }, { 1, "flagA" }, { 2, "flagB" }, { 4, "flagC" }, { 5, "flagAC" } };
449 
450  valString = "none";
451  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
452  XLAL_CHECK( valFlag == 0, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
453 
454  valString = "noflag";
455  XLAL_TRY_SILENT( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ), errnum );
456  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsUserFlag() failed to catch invalid bitflag value\n" );
457 
458  valString = "none,flagA";
459  XLAL_TRY_SILENT( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ), errnum );
460  XLAL_CHECK( errnum != 0, XLAL_EFAILED, "XLALParseStringValueAsUserFlag() failed to catch invalid bitflag value\n" );
461 
462  valString = "flagA";
463  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
464  XLAL_CHECK( valFlag == 1, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
465 
466  valString = "flagB";
467  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
468  XLAL_CHECK( valFlag == 2, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
469 
470  valString = "flagA,flagC";
471  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
472  XLAL_CHECK( valFlag == 5, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
473 
474  valString = "flagAC";
475  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
476  XLAL_CHECK( valFlag == 5, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
477 
478  valString = "flagB,flagA,flagC,flagA";
479  XLAL_CHECK( XLALParseStringValueAsUserFlag ( &valFlag, &flagData, valString ) == XLAL_SUCCESS, XLAL_EFUNC );
480  XLAL_CHECK( valFlag == 7, XLAL_ETOL, "XLALParseStringValueAsUserFlag(%s), failed, return = %i", valString, valFlag );
481 
482  return XLAL_SUCCESS;
483 } // test_ParseStringValue()
484 
485 // test string-vector parsing function XLALParseStringValueAsStringVector()
486 int
487 test_ParseStringVector(void)
488 {
489 #define STR1 "Hello, world!"
490 #define STR2 "xyda 3!#4134"
491 #define STR3 "&\\//.. :: some junk"
492 #define STR4 "H1"
493 #define STR5 "H2"
494 #define STR6 "L1"
495 
496  LALStringVector *strVect1;
497  XLAL_CHECK ( (strVect1 = XLALCreateStringVector ( STR1, STR2, STR3, STR4, STR5, NULL )) != NULL, XLAL_EFUNC );
498 
499  XLAL_CHECK ( (strVect1 = XLALAppendString2Vector ( strVect1, STR6 )) != NULL, XLAL_EFUNC );
500 
501  // now 'print' this string-vector as a 'string-value', then re-parse back into a vector:
502  CHAR *strValue1 = NULL;
503  LALStringVector *strVect2 = NULL;
504  XLAL_CHECK ( (strValue1 = XLALPrintStringValueOfSTRINGVector ( &strVect1 )) != NULL, XLAL_EFUNC );
505  XLALPrintInfo ("String value of initial string-vector: %s\n", strValue1 );
506 
507  XLAL_CHECK ( XLALParseStringValueAsSTRINGVector ( &strVect2, strValue1 ) == XLAL_SUCCESS, XLAL_EFUNC );
508  CHAR *strValue2 = NULL;
509  XLAL_CHECK ( (strValue2 = XLALPrintStringValueOfSTRINGVector ( &strVect2 )) != NULL, XLAL_EFUNC );
510  XLALPrintInfo ("String value of re-parsed string-vector: %s\n", strValue2 );
511 
512  // ----- compare results
513  // 1) compare string values
514  XLAL_CHECK ( strcmp ( strValue1, strValue2 ) == 0, XLAL_EFAILED, "String values differ:\nstrValue1 = %s\nstrValue2 = %s\n", strValue1, strValue2 );
515 
516  // 2) compare string vectors
517  UINT4 len1 = strVect1->length;
518  UINT4 len2 = strVect2->length;
519  XLAL_CHECK ( len1 == len2, XLAL_EFAILED, "String vectors vect1 and vect2 have different lengths (%d != %d )\n", len1, len2 );
520 
521  for ( UINT4 i = 0; i < len1; i++ )
522  {
523  if ( strcmp ( strVect1->data[i], strVect2->data[i] ) != 0 )
524  {
525  for ( UINT4 j=0; j < len1; j ++ ) {
526  XLALPrintError ("j = %d: s1[j] = %6s, s2[j] = %6s\n", j, strVect1->data[j], strVect2->data[j] );
527  }
528  XLAL_ERROR ( XLAL_EFAILED, "Printed and re-parsed string-vector differ!\n" );
529  } // if s1[i] != s2[i]
530 
531  } // for i < len
532 
533  // clean up memory
534  XLALFree ( strValue1 );
535  XLALFree ( strValue2 );
536 
537  XLALDestroyStringVector ( strVect1 );
538  XLALDestroyStringVector ( strVect2 );
539 
540  return XLAL_SUCCESS;
541 
542 } // test_ParseStringVector()
543 
544 
545 // test string-vector parsing function XLALParseStringValueAsStringVector()
546 int
547 test_ParseREAL8Vector(void)
548 {
549  const char *csvIn = "0.1,5,-5.1e+99,1.23456789e-99,inf,nan";
550  REAL8 vals[] = {0.1, 5, -5.1e+99, 1.23456789e-99 }; // only finite values for comparison
551 
552  // parse csv string as REAL8Vector:
553  REAL8Vector *vect1 = NULL;
554  XLAL_CHECK ( XLALParseStringValueAsREAL8Vector ( &vect1, csvIn ) == XLAL_SUCCESS, XLAL_EFUNC );
555 
556  // test1: re-print as string, compare strings
557  char *csvOut;
558  XLAL_CHECK ( (csvOut = XLALPrintStringValueOfREAL8Vector ( &vect1 )) != NULL, XLAL_EFUNC );
559  XLAL_CHECK ( strcmp ( csvIn, csvOut ) == 0, XLAL_EFAILED, "csvIn != csvOut:\ncsvIn = %s\ncsvOut = %s\n", csvIn, csvOut );
560 
561  // test2: compare finite parsed values:
562  for ( UINT4 i = 0; i < 4; i ++ ) {
563  XLAL_CHECK ( vect1->data[i] == vals[i], XLAL_EFAILED, "Parsed %d-th value differs from input: %.16g != %.16g\n", i, vect1->data[i], vals[i] );
564  }
565  // check non-finite values
566  XLAL_CHECK ( fpclassify ( vect1->data[4] ) == FP_INFINITE, XLAL_EFAILED, "Failed to parse 'inf'\n");
567  XLAL_CHECK ( fpclassify ( vect1->data[5] ) == FP_NAN, XLAL_EFAILED, "Failed to parse 'nan'\n");
568 
569  // clean up memory
570  XLALFree ( csvOut );
571  XLALDestroyREAL8Vector ( vect1 );
572 
573  return XLAL_SUCCESS;
574 
575 } // test_ParseREAL8Vector()
LALCheckMemoryLeaks
void LALCheckMemoryLeaks(void)
Definition: LALMalloc.c:784
test_ParseStringVector
int test_ParseStringVector(void)
Definition: UserInputParseTest.c:487
STR6
#define STR6
STR4
#define STR4
STR1
#define STR1
main
int main(void)
Definition: UserInputParseTest.c:44
test_ParseREAL8Vector
int test_ParseREAL8Vector(void)
Definition: UserInputParseTest.c:547
test_ParseStringValue
int test_ParseStringValue(void)
test various string-value parser functions: XLALParseStringValueAsINT8(), XLALParseStringValueAsINT4(...
Definition: UserInputParseTest.c:74
STR3
#define STR3
STR5
#define STR5
STR2
#define STR2
XLALPrintInfo
int XLALPrintInfo(const char *fmt,...)
Definition: XLALError.c:90
XLALPrintError
int XLALPrintError(const char *fmt,...)
Definition: XLALError.c:68
LAL_REAL8_EPS
#define LAL_REAL8_EPS
Difference between 1 and the next resolvable REAL8 2^-52.
Definition: LALConstants.h:61
LAL_REAL4_EPS
#define LAL_REAL4_EPS
Difference between 1 and the next resolvable REAL4 2^-23.
Definition: LALConstants.h:57
UINT8
uint64_t UINT8
Eight-byte unsigned integer; on some platforms this is equivalent to unsigned long int instead.
Definition: LALAtomicDatatypes.h:62
REAL8
double REAL8
Double precision real floating-point number (8 bytes).
Definition: LALAtomicDatatypes.h:103
INT8
int64_t INT8
Eight-byte signed integer; on some platforms this is equivalent to long int instead.
Definition: LALAtomicDatatypes.h:61
LAL_UINT8_C
#define LAL_UINT8_C(c)
Macro for use in defining v as an UINT8 constant.
Definition: LALAtomicDatatypes.h:99
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
REAL4
float REAL4
Single precision real floating-point number (4 bytes).
Definition: LALAtomicDatatypes.h:102
XLALFree
#define XLALFree(p)
Definition: LALMalloc.h:47
LAL_INT8_FORMAT
#define LAL_INT8_FORMAT
Definition: LALStdio.h:128
LAL_UINT8_FORMAT
#define LAL_UINT8_FORMAT
Definition: LALStdio.h:131
XLALAppendString2Vector
LALStringVector * XLALAppendString2Vector(LALStringVector *vect, const CHAR *string)
Append the given string to the string-vector (XLAL interface), return pointer to the resulting string...
Definition: StringVector.c:47
XLALDestroyStringVector
void XLALDestroyStringVector(LALStringVector *vect)
XLAL-interface: Free a string-vector ;)
Definition: StringVector.c:204
XLALCreateStringVector
LALStringVector * XLALCreateStringVector(const CHAR *str1,...)
Create a StringVector from the list of strings passed as arguments.
Definition: StringVector.c:100
LIGOTimeGPSRange
LIGOTimeGPS LIGOTimeGPSRange[2]
A range of GPS times; first element is minimum, second element is maximum of range.
Definition: UserInputParse.h:71
XLALParseStringValueAsGPS
int XLALParseStringValueAsGPS(LIGOTimeGPS *gps, const char *valString)
Parse a string representing a GPS time into LIGOTimeGPS, without loss of (ns) accuracy.
Definition: UserInputParse.c:287
XLALParseStringValueAsRAJRange
int XLALParseStringValueAsRAJRange(REAL8Range rajRange, const char *valString)
Parse a string representing a range of RAJ values into a REAL8Range.
Definition: UserInputParse.c:586
XLALParseStringValueAsUINT8
int XLALParseStringValueAsUINT8(UINT8 *valUINT8, const char *valString)
Parse a string into an UINT8 This ignores initial whitespace, but throws an error on any non-converte...
Definition: UserInputParse.c:102
XLALParseStringValueAsUINT4
int XLALParseStringValueAsUINT4(UINT4 *valUINT4, const char *valString)
Parse a string into an UINT4 This ignores initial whitespace, but throws an error on any non-converte...
Definition: UserInputParse.c:135
XLALParseStringValueAsEPOCHRange
int XLALParseStringValueAsEPOCHRange(LIGOTimeGPSRange gpsRange, const char *valString)
Parse a string representing a range of LIGOTimeGPS values into a LIGOTimeGPSRange.
Definition: UserInputParse.c:548
XLALParseStringValueAsINT4PlusFrac
int XLALParseStringValueAsINT4PlusFrac(INT4 *valINT4, REAL8 *valFrac, const char *valString)
Parse a string containing a floating-point number into integer and fractional part,...
Definition: UserInputParse.c:203
REAL8Range
REAL8 REAL8Range[2]
A range of REAL8 values; first element is minimum, second element is maximum of range.
Definition: UserInputParse.h:61
XLALParseStringValueAsEPOCH
int XLALParseStringValueAsEPOCH(LIGOTimeGPS *gps, const char *valString)
Parse a string representing an 'epoch' into an LIGOTimeGPS, allowing both GPS and MJD(TT) inputs,...
Definition: UserInputParse.c:314
XLALParseStringValueAsINT4
int XLALParseStringValueAsINT4(INT4 *valINT4, const char *valString)
Parse a string into an INT4 This ignores initial whitespace, but throws an error on any non-converted...
Definition: UserInputParse.c:79
XLALParseStringValueAsREAL4
int XLALParseStringValueAsREAL4(REAL4 *valREAL4, const char *valString)
Parse a string into a REAL4.
Definition: UserInputParse.c:179
XLAL_BIT2IDX
#define XLAL_BIT2IDX(b)
Convert an unsigned long single bit b into an index, i.e.
Definition: UserInputParse.h:49
XLALParseStringValueAsREAL8Range
int XLALParseStringValueAsREAL8Range(REAL8Range real8Range, const char *valString)
Parse a string representing a range of REAL8 values into a REAL8Range.
Definition: UserInputParse.c:473
XLALParseStringValueAsINT8
int XLALParseStringValueAsINT8(INT8 *valINT8, const char *valString)
Parse a string into an INT8 This ignores initial whitespace, but throws an error on any non-converted...
Definition: UserInputParse.c:50
INT4Range
INT4 INT4Range[2]
A range of INT4 values; first element is minimum, second element is maximum of range.
Definition: UserInputParse.h:66
XLALParseStringValueAsSTRINGVector
int XLALParseStringValueAsSTRINGVector(LALStringVector **strVect, const CHAR *valString)
Parse a string containing a list of comma-separated values (CSV) into a StringVector.
Definition: UserInputParse.c:805
XLALParseStringValueAsDECJRange
int XLALParseStringValueAsDECJRange(REAL8Range decjRange, const char *valString)
Parse a string representing a range of DECJ values into a REAL8Range.
Definition: UserInputParse.c:624
XLALParseStringValueAsINT4Range
int XLALParseStringValueAsINT4Range(INT4Range int4Range, const char *valString)
Parse a string representing a range of INT4 values into a INT4Range.
Definition: UserInputParse.c:510
XLAL_IDX2BIT
#define XLAL_IDX2BIT(i)
Convert an unsigned long index i into a bit, i.e.
Definition: UserInputParse.h:44
XLALParseStringValueAsREAL8
int XLALParseStringValueAsREAL8(REAL8 *valREAL8, const char *valString)
Parse a string into a REAL8 This ignores initial whitespace, but throws an error on any non-converted...
Definition: UserInputParse.c:158
XLALParseStringValueAsUserEnum
int XLALParseStringValueAsUserEnum(int *valEnum, const UserChoices *enumData, const char *valString)
Parse a string representing a user selection of an enumeration value.
Definition: UserInputParse.c:662
XLALParseStringValueAsUserFlag
int XLALParseStringValueAsUserFlag(int *valFlag, const UserChoices *flagData, const char *valString)
Parse a string representing a user selection of a set of bitflags.
Definition: UserInputParse.c:695
XLALPrintStringValueOfSTRINGVector
char * XLALPrintStringValueOfSTRINGVector(LALStringVector **valSTRINGVector)
Return 'string value' (allocated here) of a STRINGVector, by turning into comma-separated list of str...
Definition: UserInputPrint.c:340
XLALDestroyREAL8Vector
void XLALDestroyREAL8Vector(REAL8Vector *vector)
XLAL_TRY_SILENT
#define XLAL_TRY_SILENT(statement, errnum)
Performs the same actions as XLAL_TRY(), but additionally silences any error/warning/etc.
Definition: XLALError.h:600
XLAL_ERROR
#define XLAL_ERROR(...)
Macro to invoke a failure from a XLAL routine returning an integer.
Definition: XLALError.h:700
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_CHECK_MAIN
#define XLAL_CHECK_MAIN(assertion,...)
Macro to test an assertion and invoke a failure if it is not true in a C main() routine.
Definition: XLALError.h:885
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_ETOL
@ XLAL_ETOL
Failed to reach specified tolerance.
Definition: XLALError.h:458
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
XLALGPSSet
LIGOTimeGPS * XLALGPSSet(LIGOTimeGPS *epoch, INT4 gpssec, INT8 gpsnan)
Sets GPS time given GPS integer seconds and residual nanoseconds.
Definition: XLALTime.c:63
LALStringVector
Vector of type CHAR*, ie 'strings', see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:82
LALStringVector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:86
LALStringVector::data
CHAR ** data
Pointer to the data array.
Definition: LALDatatypes.h:87
LIGOTimeGPS
Epoch relative to GPS epoch, see LIGOTimeGPS type for more details.
Definition: LALDatatypes.h:458
LIGOTimeGPS::gpsSeconds
INT4 gpsSeconds
Seconds since 0h UTC 6 Jan 1980.
Definition: LALDatatypes.h:459
LIGOTimeGPS::gpsNanoSeconds
INT4 gpsNanoSeconds
Residual nanoseconds.
Definition: LALDatatypes.h:460
REAL8Vector
Vector of type REAL8, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:154
REAL8Vector::data
REAL8 * data
Pointer to the data array.
Definition: LALDatatypes.h:159
UserChoices
Possible choices the user may select for an enumeration or bitflag.
Definition: UserInputParse.h:79