Teuchos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Validator_UnitTest.cpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Teuchos: Common Tools Package
5 // Copyright (2004) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ***********************************************************************
40 // @HEADER
41 #include "Teuchos_UnitTestHarness.hpp"
42 #include "Teuchos_VerboseObject.hpp"
43 #include "Teuchos_ParameterList.hpp"
44 #include "Teuchos_StandardParameterEntryValidators.hpp"
45 
46 
47 // 2010/07/30: rabartl: Here I just added all the unit tests to the Teuchos
48 // namespace to remove some clutter.
49 
50 
51 namespace Teuchos {
52 
53 
57 TEUCHOS_UNIT_TEST(Teuchos_Validators, numberValidators)
58 {
59  /*
60  * Testing Int Validator.
61  */
62  RCP<ParameterList> intList =
63  rcp(new ParameterList("Int List"));
64  RCP<EnhancedNumberValidator<int> > intVali =
65  rcp(new EnhancedNumberValidator<int>(0,10,4));
66  TEST_ASSERT(intVali->getMin() == 0);
67  TEST_ASSERT(intVali->getMax() == 10);
68  TEST_ASSERT(intVali->getStep() == 4);
69  TEST_ASSERT(intVali->hasMin());
70  TEST_ASSERT(intVali->hasMax());
71  RCP<EnhancedNumberValidator<int> > intVali2 =
72  rcp(new EnhancedNumberValidator<int>());
73  TEST_ASSERT(!intVali2->hasMin());
74  TEST_ASSERT(!intVali2->hasMax());
75  TEST_ASSERT(intVali2->getMin() == std::numeric_limits<int>::min());
76  TEST_ASSERT(intVali2->getMax() == std::numeric_limits<int>::max());
77  TEST_ASSERT(intVali2->getStep() == EnhancedNumberTraits<int>::defaultStep());
78  intList->set("Int Parameter", 5, "int parameter", intVali);
79  TEST_NOTHROW(intList->validateParameters(*intList));
80  TEST_THROW(intList->set("Int Parameter", 11),
81  Exceptions::InvalidParameterValue);
82  TEST_THROW(intList->set("Double Parameter", 5.0, "double parameter", intVali),
83  Exceptions::InvalidParameterType);
84 
85  // Test String Conversions with int
86  RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
87  RCP<ParameterList> userList = rcp(new ParameterList("User List"));
88  TEST_NOTHROW(validList->set("Int Parameter", 4, "int parameter",
89  intVali));
90 #ifdef HAVE_TEUCHOSCORE_CXX11
91  TEST_NOTHROW(userList->set("Int Parameter", "x4"));
92  TEST_THROW(userList->validateParameters(*validList),
93  Exceptions::InvalidArgument);
94  TEST_NOTHROW(userList->set("Int Parameter", "4x"));
95  TEST_THROW(userList->validateParameters(*validList),
96  Exceptions::InvalidArgument);
97  TEST_NOTHROW(userList->set("Int Parameter", "12")); // ok string bad range
98  TEST_THROW(userList->validateParameters(*validList),
99  Exceptions::InvalidArgument);
100 #endif
101  userList = rcp(new ParameterList("User List"));
102  TEST_NOTHROW(userList->set("Int Parameter", 4));
103  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
104  TEST_NOTHROW(userList->set("Int Parameter", "8"));
105  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
106  int readInt = userList->getEntry("Int Parameter").getValue<int>(&readInt);
107  TEST_ASSERT(readInt == 8);
108 
109  // check string can generate out of range
110  userList = rcp(new ParameterList("User List"));
111  TEST_NOTHROW(userList->set("Int Parameter", "20"));
112  TEST_THROW(userList->validateParameters(*validList),
113  Exceptions::InvalidParameterType);
114 
115  /*
116  * Testing Short Validator.
117  */
118  RCP<ParameterList> shortList =
119  rcp(new ParameterList("Short List"));
120  RCP<EnhancedNumberValidator<short> > shortVali =
121  rcp(new EnhancedNumberValidator<short>(0,10,4));
122  TEST_ASSERT(shortVali->getMin() == 0);
123  TEST_ASSERT(shortVali->getMax() == 10);
124  TEST_ASSERT(shortVali->getStep() == 4);
125  TEST_ASSERT(shortVali->hasMin());
126  TEST_ASSERT(shortVali->hasMax());
127  RCP<EnhancedNumberValidator<short> > shortVali2 =
128  rcp(new EnhancedNumberValidator<short>());
129  TEST_ASSERT(!shortVali2->hasMin());
130  TEST_ASSERT(!shortVali2->hasMax());
131  TEST_ASSERT(shortVali2->getMin() == std::numeric_limits<short>::min());
132  TEST_ASSERT(shortVali2->getMax() == std::numeric_limits<short>::max());
133  TEST_ASSERT(shortVali2->getStep() == EnhancedNumberTraits<short>::defaultStep());
134  shortList->set("Short Parameter", (short)5, "short parameter", shortVali);
135  TEST_NOTHROW(shortList->validateParameters(*shortList));
136  TEST_THROW(shortList->set("Short Parameter", (short)11),
137  Exceptions::InvalidParameterValue);
138  TEST_THROW(shortList->set("Double Parameter", 5.0, "double parameter", shortVali),
139  Exceptions::InvalidParameterType);
140 
141  // Test String Conversions with short
142  validList = rcp(new ParameterList("Valid List"));
143  userList = rcp(new ParameterList("User List"));
144  TEST_NOTHROW(validList->set("Short Parameter", (short)4, "short parameter",
145  shortVali));
146 #ifdef HAVE_TEUCHOSCORE_CXX11
147  TEST_NOTHROW(userList->set("Short Parameter", "x4"));
148  TEST_THROW(userList->validateParameters(*validList),
149  Exceptions::InvalidArgument);
150  TEST_NOTHROW(userList->set("Short Parameter", "4x"));
151  TEST_THROW(userList->validateParameters(*validList),
152  Exceptions::InvalidArgument);
153  TEST_NOTHROW(userList->set("Short Parameter", "12")); // ok string bad range
154  TEST_THROW(userList->validateParameters(*validList),
155  Exceptions::InvalidArgument);
156 #endif
157  userList = rcp(new ParameterList("User List"));
158  TEST_NOTHROW(userList->set("Short Parameter", (short)4));
159  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
160  TEST_NOTHROW(userList->set("Short Parameter", "8"));
161  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
162  short readShort = userList->getEntry("Short Parameter").getValue<short>(&readShort);
163  TEST_ASSERT(readShort == 8);
164 
165  // check string can generate out of range
166  userList = rcp(new ParameterList("User List"));
167  TEST_NOTHROW(userList->set("Short Parameter", "20"));
168  TEST_THROW(userList->validateParameters(*validList),
169  Exceptions::InvalidParameterType);
170 
171  /*
172  * Testing Float Validator.
173  */
174  RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
175  RCP<EnhancedNumberValidator<float> > floatVali =
176  rcp(new EnhancedNumberValidator<float>(0,10.0,4.0,6));
177  TEST_ASSERT(floatVali->getMin() == 0.0);
178  TEST_ASSERT(floatVali->getMax() == 10.0);
179  TEST_ASSERT(floatVali->getStep() == 4.0);
180  TEST_ASSERT(floatVali->getPrecision() == 6);
181  TEST_ASSERT(floatVali->hasMin());
182  TEST_ASSERT(floatVali->hasMax());
183  RCP<EnhancedNumberValidator<float> > floatVali2 =
184  rcp(new EnhancedNumberValidator<float>());
185  TEST_ASSERT(!floatVali2->hasMin());
186  TEST_ASSERT(!floatVali2->hasMax());
187  TEST_ASSERT(floatVali2->getMin() == EnhancedNumberTraits<float>::min());
188  TEST_ASSERT(floatVali2->getMax() == EnhancedNumberTraits<float>::max());
189  TEST_ASSERT(floatVali2->getStep() == EnhancedNumberTraits<float>::defaultStep());
190  TEST_ASSERT(floatVali2->getPrecision() == EnhancedNumberTraits<float>::defaultPrecision());
191  floatList->set("Float Parameter", (float)5.0, "float parameter", floatVali);
192  TEST_NOTHROW(floatList->validateParameters(*floatList));
193  TEST_THROW(floatList->set("Float Parameter", (float)11.0),
194  Exceptions::InvalidParameterValue);
195  TEST_THROW(floatList->set("Int Parameter", 5, "int parameter", floatVali),
196  Exceptions::InvalidParameterType);
197 
198  // Test String Conversions with float
199  validList = rcp(new ParameterList("Valid List"));
200  userList = rcp(new ParameterList("User List"));
201  TEST_NOTHROW(validList->set("Float Parameter", (float)4.0, "float parameter",
202  floatVali));
203 #ifdef HAVE_TEUCHOSCORE_CXX11
204  TEST_NOTHROW(userList->set("Float Parameter", "x4.0"));
205  TEST_THROW(userList->validateParameters(*validList),
206  Exceptions::InvalidArgument);
207  TEST_NOTHROW(userList->set("Float Parameter", "4.0x"));
208  TEST_THROW(userList->validateParameters(*validList),
209  Exceptions::InvalidArgument);
210  TEST_NOTHROW(userList->set("Float Parameter", "12.0")); // ok string bad range
211  TEST_THROW(userList->validateParameters(*validList),
212  Exceptions::InvalidArgument);
213 #endif
214  userList = rcp(new ParameterList("User List"));
215  TEST_NOTHROW(userList->set("Float Parameter", (float)8.0));
216  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
217  TEST_NOTHROW(userList->set("Float Parameter", "8.0"));
218  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
219  float readFloat = userList->getEntry("Float Parameter").getValue<float>(&readFloat);
220  TEST_ASSERT(readFloat == 8.0);
221 
222  // check string can generate out of range
223  userList = rcp(new ParameterList("User List"));
224  TEST_NOTHROW(userList->set("Float Parameter", "20.0"));
225  TEST_THROW(userList->validateParameters(*validList),
226  Exceptions::InvalidParameterType);
227 
228  /*
229  * Testing Double Validator.
230  */
231  RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
232  RCP<EnhancedNumberValidator<double> > doubleVali =
233  rcp(new EnhancedNumberValidator<double>(0,10.0,4.0,6));
234  TEST_ASSERT(doubleVali->getMin() == 0.0);
235  TEST_ASSERT(doubleVali->getMax() == 10.0);
236  TEST_ASSERT(doubleVali->getStep() == 4.0);
237  TEST_ASSERT(doubleVali->getPrecision() == 6);
238  TEST_ASSERT(doubleVali->hasMin());
239  TEST_ASSERT(doubleVali->hasMax());
240  RCP<EnhancedNumberValidator<double> > doubleVali2 =
241  rcp(new EnhancedNumberValidator<double>());
242  TEST_ASSERT(!doubleVali2->hasMin());
243  TEST_ASSERT(!doubleVali2->hasMax());
244  TEST_ASSERT(doubleVali2->getMin() == EnhancedNumberTraits<double>::min());
245  TEST_ASSERT(doubleVali2->getMax() == EnhancedNumberTraits<double>::max());
246  TEST_ASSERT(doubleVali2->getStep() == EnhancedNumberTraits<double>::defaultStep());
247  TEST_ASSERT(doubleVali2->getPrecision() == EnhancedNumberTraits<double>::defaultPrecision());
248  doubleList->set("Double Parameter", (double)5.0, "double parameter", doubleVali);
249  TEST_NOTHROW(doubleList->validateParameters(*doubleList));
250  TEST_THROW(doubleList->set("Double Parameter", (double)11.0),
251  Exceptions::InvalidParameterValue);
252  TEST_THROW(doubleList->set("Int Parameter", 5, "int parameter", doubleVali),
253  Exceptions::InvalidParameterType);
254 
255  // Test String Conversions with double
256  validList = rcp(new ParameterList("Valid List"));
257  userList = rcp(new ParameterList("User List"));
258  TEST_NOTHROW(validList->set("Double Parameter", 4.0, "double parameter",
259  doubleVali));
260 #ifdef HAVE_TEUCHOSCORE_CXX11
261  TEST_NOTHROW(userList->set("Double Parameter", "x4.0"));
262  TEST_THROW(userList->validateParameters(*validList),
263  Exceptions::InvalidArgument);
264  TEST_NOTHROW(userList->set("Double Parameter", "4.0x"));
265  TEST_THROW(userList->validateParameters(*validList),
266  Exceptions::InvalidArgument);
267  TEST_NOTHROW(userList->set("Double Parameter", "12.0"));
268  TEST_THROW(userList->validateParameters(*validList), // bad range
269  Exceptions::InvalidArgument);
270 #endif
271  userList = rcp(new ParameterList("Valid List"));
272  TEST_NOTHROW(userList->set("Double Parameter", 8.0));
273  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
274  TEST_NOTHROW(userList->set("Double Parameter", "8.0"));
275  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
276  double readDouble = userList->getEntry("Double Parameter").getValue<double>(&readDouble);
277  TEST_ASSERT(readDouble == 8.0);
278 
279  // check string can generate out of range
280  userList = rcp(new ParameterList("User List"));
281  TEST_NOTHROW(userList->set("Double Parameter", "20.0"));
282  TEST_THROW(userList->validateParameters(*validList),
283  Exceptions::InvalidParameterType);
284  }
285 
286 TEUCHOS_UNIT_TEST(Teuchos_Validators, anyNumberValidator)
287 {
288  RCP<ParameterList> userList = rcp(new ParameterList("User List"));
289  RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
290 
291  Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intDoubleTypes;
292  intDoubleTypes.allowString(false);
293  Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intStringTypes;
294  intStringTypes.allowDouble(false);
295  Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intTypes;
296  intTypes.allowDouble(false);
297  intTypes.allowString(false);
298 
299  // set up validators to test
300  // default prefers double and allows string and int
301  RCP<Teuchos::AnyNumberParameterEntryValidator> allValidator =
302  Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator() );
303  RCP<Teuchos::AnyNumberParameterEntryValidator> intDoubleValidator =
304  Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
305  Teuchos::AnyNumberParameterEntryValidator::PREFER_DOUBLE, intDoubleTypes) );
306  RCP<Teuchos::AnyNumberParameterEntryValidator> intStringValidator =
307  Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
308  Teuchos::AnyNumberParameterEntryValidator::PREFER_INT, intStringTypes) );
309  RCP<Teuchos::AnyNumberParameterEntryValidator> intValidator =
310  Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
311  Teuchos::AnyNumberParameterEntryValidator::PREFER_INT, intTypes) );
312 
313  // first check the 'good' setups which do not throw
314  TEST_NOTHROW(validList->set( "allParameter", "1.1", "documentation",
315  allValidator));
316  TEST_NOTHROW(validList->set( "allParameter", 1.1, "documentation",
317  allValidator));
318  TEST_NOTHROW(validList->set( "allParameter", "1", "documentation",
319  allValidator));
320  TEST_NOTHROW(validList->set( "allParameter", 1, "documentation",
321  allValidator));
322  TEST_NOTHROW(validList->set( "intDoubleParameter", 1.1, "documentation",
323  intDoubleValidator));
324  TEST_NOTHROW(validList->set( "intDoubleParameter", 1, "documentation",
325  intDoubleValidator));
326  TEST_NOTHROW(validList->set( "intStringParameter", "1", "documentation",
327  intStringValidator));
328  TEST_NOTHROW(validList->set( "intStringParameter", 1, "documentation",
329  intStringValidator));
330  TEST_NOTHROW(validList->set( "intParameter", 1, "documentation",
331  intValidator));
332 
333  // This was a special case that might warrant discussion.
334  // The issue is for validators which accept string/int but not double.
335  // In the original setup the validator would always call getDouble
336  // internally and accept a string of "1.1" without error.
337  TEST_NOTHROW(validList->set( "intStringParameter", "1.1", "documentation",
338  intStringValidator));
339 
340  //
341  // these are some cases which throw independent of HAVE_TEUCHOSCORE_CXX11
342  //
343 
344  // if string it not allowed you can't use a string ever
345  TEST_THROW(validList->set( "intDoubleParameter", "1.1", "documentation",
346  intDoubleValidator), Exceptions::InvalidParameterType);
347 
348  // it also throws for a double number - double not allowed
349  TEST_THROW(validList->set( "intStringParameter", 1.1, "documentation",
350  intStringValidator), Exceptions::InvalidArgument);
351 
352  // for int only it can't be a string - any string will throw
353  TEST_THROW(validList->set( "intParameter", "1", "documentation",
354  intValidator), Exceptions::InvalidParameter);
355 
356  // this int only it can't be a double because double is not allowed
357  TEST_THROW(validList->set( "intParameter", 1.1, "documentation",
358  intValidator), Exceptions::InvalidParameter);
359 
360  //
361  // these behaviors now depend on HAVE_TEUCHOSCORE_CXX11
362  // std::stod and std::stoi will be used for HAVE_TEUCHOSCORE_CXX11
363  // std::atof and std::atoi will be used for no CXX11
364  //
365 #ifdef HAVE_TEUCHOSCORE_CXX11
366  // for double types we throw for badly formatted string on std::stod
367  // this will check the double type first because it is PREFER_DOUBLE
368  TEST_THROW(validList->set( "allParameter", "1.1x", "documentation",
369  allValidator), Exceptions::InvalidArgument);
370  TEST_THROW(validList->set( "intDoubleParameter", "1.1x", "documentation",
371  allValidator), Exceptions::InvalidArgument);
372  TEST_THROW(validList->set( "allParameter", "x1.1", "documentation",
373  allValidator), Exceptions::InvalidArgument);
374  TEST_THROW(validList->set( "intDoubleParameter", "x1.1", "documentation",
375  allValidator), Exceptions::InvalidArgument);
376  // for int/string but no double - std::stoi throws for invalid formatting
377  TEST_THROW(validList->set( "intStringParameter", "1x", "documentation",
378  intStringValidator), Exceptions::InvalidArgument);
379  TEST_THROW(validList->set( "intStringParameter", "x1", "documentation",
380  intStringValidator), Exceptions::InvalidArgument);
381  TEST_THROW(validList->set( "intStringParameter", "1 x", "documentation",
382  intStringValidator), Exceptions::InvalidArgument);
383 #else
384  // for int/double/string std::atod does NOT throw - this is the old behavior
385  // this is different now when HAVE_TEUCHOSCORE_CXX11 is ON - see above
386  TEST_NOTHROW(validList->set( "allParameter", "1.1x", "documentation",
387  allValidator));
388  // for int/string std::atoi does NOT throw - this is the old behavior
389  // this is different now when HAVE_TEUCHOSCORE_CXX11 is ON - see above
390  TEST_NOTHROW(validList->set( "intStringParameter", "1.1x", "documentation",
391  intStringValidator));
392 #endif
393 }
394 
395 TEUCHOS_UNIT_TEST(Teuchos_Validators, boolValidator)
396 {
397  RCP<ParameterList> userList = rcp(new ParameterList("User List"));
398  RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
399 
400  // first without validator - accepts only true/false
401  validList->set( "justBool", false, "documentation" );
402  TEST_NOTHROW(userList->set( "justBool", false));
403  TEST_NOTHROW(userList->validateParameters(*validList));
404  TEST_NOTHROW(userList->set( "justBool", true));
405  TEST_NOTHROW(userList->validateParameters(*validList));
406  // this will not validate because we did not add a bool validator
407  TEST_NOTHROW(userList->set( "justBool", "true"));
408  TEST_THROW(userList->validateParameters(*validList),
409  Exceptions::InvalidParameterType);
410  // this will not validate because we did not add a bool validator
411  TEST_NOTHROW(userList->set( "justBool", "false"));
412  TEST_THROW(userList->validateParameters(*validList),
413  Exceptions::InvalidParameterType);
414 
415  // now with BoolParameterEntryValidator validator
416  // accepts true/false/"true"/"false"
417  RCP<Teuchos::BoolParameterEntryValidator> boolValidator =
418  Teuchos::rcp( new Teuchos::BoolParameterEntryValidator() );
419  userList = rcp(new ParameterList("User List")); // make a new list
420  validList = rcp(new ParameterList("Valid List")); // make a new list
421  validList->set( "boolOrString", false, "documentation", boolValidator );
422  TEST_NOTHROW(userList->set( "boolOrString", false));
423  TEST_NOTHROW(userList->validateParameters(*validList));
424  TEST_NOTHROW(userList->set( "boolOrString", true));
425  TEST_NOTHROW(userList->validateParameters(*validList));
426  // this will validate because we added a bool validator
427  TEST_NOTHROW(userList->set( "boolOrString", "true"));
428  TEST_NOTHROW(userList->validateParameters(*validList));
429  // this will validate because we added a bool validator
430  TEST_NOTHROW(userList->set( "boolOrString", "false"));
431  TEST_NOTHROW(userList->validateParameters(*validList));
432  // but only "false" and "true" work - anything else will not validate
433  TEST_NOTHROW(userList->set( "boolOrString", "falsex")); // sets ok
434  TEST_THROW(userList->validateParameters(*validList), // but throws
435  Exceptions::InvalidParameterType);
436 
437  // now with BoolParameterEntryValidator validator
438  // but consider what happens if we created it using "false" instead of false
439  // this should still work identically to the previous case
440  userList = rcp(new ParameterList("User List")); // make a new list
441  validList = rcp(new ParameterList("Valid List")); // make a new list
442  validList->set( "boolOrString", "false", "documentation", boolValidator );
443  TEST_NOTHROW(userList->set( "boolOrString", false));
444  TEST_NOTHROW(userList->validateParameters(*validList));
445  TEST_NOTHROW(userList->set( "boolOrString", true ));
446  TEST_NOTHROW(userList->validateParameters(*validList));
447  // this will validate because we added a bool validator
448  TEST_NOTHROW(userList->set( "boolOrString", "true"));
449  TEST_NOTHROW(userList->validateParameters(*validList));
450  // this will validate because we added a bool validator
451  TEST_NOTHROW(userList->set( "boolOrString", "false"));
452  TEST_NOTHROW(userList->validateParameters(*validList));
453  // but only "false" and "true" work - anything else will not validate
454  TEST_NOTHROW(userList->set( "boolOrString", "falsex")); // sets ok
455  TEST_THROW(userList->validateParameters(*validList), // but throws
456  Exceptions::InvalidParameterType);
457 
458  // do another test using validateParametersAndSetDefaults
459  userList = rcp(new ParameterList("User List")); // make a new list
460  validList = rcp(new ParameterList("Valid List")); // make a new list
461  // Default values for parameters are bool
462  validList->set("boolOne", true, "doc", boolValidator);
463  validList->set("boolTwo", false, "doc", boolValidator);
464  bool defOne = validList->getEntry("boolOne").getValue(&defOne);
465  bool defTwo = validList->getEntry("boolTwo").getValue(&defTwo);
466 
467  // Create user parameter list
468  userList->set("boolOne", false); // User can provide bool value...
469  userList->set("boolTwo", "true"); // or string "true"/"false"
470  TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
471 }
472 
473 
474 /*
475  * Testing StringValidator.
476  */
477 TEUCHOS_UNIT_TEST(Teuchos_Validators, stringValidator)
478 {
479  RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
480  Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
481  RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
482  RCP<const Array<std::string> > valiVals = stringVali->validStringValues();
483  /*bool local_success = true;
484  for(int i =0; i<valiVals.size() ++i){
485  TEST_ARRAY_ELE_EQUALITY(*valiVals, i, stringVals[i]);
486  }
487  if (local_success) out << "passed\n";
488  else success = false;*/
489  TEST_COMPARE_ARRAYS(*valiVals, stringVals);
490  TEST_NOTHROW(stringList->set("String param1", "str1", "a string parameter", stringVali));
491  TEST_THROW(stringList->set("String param2", "not in list", "a string parameter", stringVali),
492  Exceptions::InvalidParameterValue);
493  TEST_THROW(stringList->set("int param", 5, "a int parameter", stringVali),
494  Exceptions::InvalidParameterType);
495 }
496 
497 
498 /*
499  * Testing StringToIntegralParameterEntryValidator.
500  */
501 TEUCHOS_UNIT_TEST(Teuchos_Validators, StringToIntegralParameterEntryValidator) {
502  Array<std::string> strVals = tuple<std::string>("str1", "str2", "str3");
503  Array<std::string> strDocs = tuple<std::string>("a str1", "a str2", "a str3");
504  Array<int> intVals = tuple<int>(1, 2, 3);
505  bool caseSensitive = true;
506  typedef StringToIntegralParameterEntryValidator<int> ret_type;
507  // Note that validator1 maps the strings to {0, 1, 2} not {1, 2, 3} as in `intVals`
508  RCP<ret_type> validator1 = rcp(new ret_type(strVals, "str1", caseSensitive));
509  RCP<ret_type> validator2 = rcp(new ret_type(strVals, intVals, "str1", caseSensitive));
510  RCP<ret_type> validator3 = rcp(new ret_type(strVals, strDocs, intVals, "str1", caseSensitive));
511  TEST_EQUALITY(strDocs, *validator3->getStringDocs());
512  ParameterList valid_pl = ParameterList();
513  valid_pl.set("Param1", "str1", "Parameter 1", validator1);
514  valid_pl.set("Param2", "str1", "Parameter 2", validator2);
515  valid_pl.set("Param3", "str1", "Parameter 3", validator3);
516  ParameterList user_pl = ParameterList();
517  user_pl.set("Param1", "str1");
518  user_pl.set("Param2", "str2");
519  user_pl.set("Param3", "str3");
520  // Test `getStringValue` and `getIntegralValue` before validation on `valid_pl`
521  TEST_EQUALITY(0, getIntegralValue<int>(valid_pl, "Param1"));
522  TEST_EQUALITY(intVals[0], getIntegralValue<int>(valid_pl, "Param2"));
523  TEST_EQUALITY(strVals[0], getStringValue<int>(valid_pl, "Param2"));
524  // Test `getStringValue` and `getIntegralValue` after validation on `user_pl`
525  user_pl.validateParametersAndSetDefaults(valid_pl);
526  TEST_EQUALITY(0, getIntegralValue<int>(user_pl, "Param1"));
527  TEST_EQUALITY(intVals[1], getIntegralValue<int>(user_pl, "Param2"));
528  TEST_EQUALITY(intVals[2], getIntegralValue<int>(user_pl, "Param3"));
529  TEST_EQUALITY(strVals[0], getStringValue<int>(user_pl, "Param1"));
530  TEST_EQUALITY(strVals[1], getStringValue<int>(user_pl, "Param2"));
531  TEST_EQUALITY(strVals[2], getStringValue<int>(user_pl, "Param3"));
532 }
533 
534 
535 /*
536  * Testing FileNameValidator.
537  */
538 TEUCHOS_UNIT_TEST(Teuchos_Validators, fileNameValidator)
539 {
540  RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
541  RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
542  TEST_ASSERT(fileNameVali->fileMustExist());
543  fileNameVali->setFileMustExist(false);
544  TEST_ASSERT(!fileNameVali->fileMustExist());
545  TEST_NOTHROW(fileNameList->set("File name param", "../path", "file name parameter",
546  fileNameVali));
547  TEST_THROW(fileNameList->set("int param", 5, "int parameter", fileNameVali),
548  Exceptions::InvalidParameterType);
549  fileNameVali->setFileMustExist(true);
550  TEST_NOTHROW(fileNameList->set("file name param", "testFile.txt", "a file name", fileNameVali));
551  TEST_THROW(fileNameList->set("file name param", "doesntexist.txt", "a file name", fileNameVali),
552  Exceptions::InvalidParameterValue);
553 }
554 
555 
556 /*
557  * Testing Array Validators.
558  */
559 TEUCHOS_UNIT_TEST(Teuchos_Validators, arrayValidators)
560 {
561 
562  /*
563  * Testing StringArrayValidator.
564  */
565  RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
566  Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
567  RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
568  RCP<ArrayStringValidator> stringArrayVali = rcp(new ArrayStringValidator(stringVali));
569  TEST_ASSERT(stringVali.get() == stringArrayVali->getPrototype().get());
570  Array<std::string> stringArray = tuple<std::string>("str2","str3","str1","str3","str2");
571  TEST_NOTHROW(stringList->set("String Array Param", stringArray, "string array parameter", stringArrayVali));
572  Array<std::string> badStringArray = tuple<std::string>("not valid","str3","str1","str3","str2");
573  TEST_THROW(stringList->set("String Array Param", badStringArray, "string array parameter", stringArrayVali),
574  Exceptions::InvalidParameterValue);
575  TEST_THROW(stringList->set("Int param", 5, "int parameter", stringArrayVali),
576  Exceptions::InvalidParameterType);
577  Array<long> longArray = tuple<long>((long)5,(long)5,(long)3);
578  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", stringArrayVali),
579  Exceptions::InvalidParameterType);
580 
581  /*
582  * Testing Int ArrayValidator.
583  */
584  RCP<ParameterList> intList = rcp(new ParameterList("Int List"));
585  RCP<EnhancedNumberValidator<int> > intVali = rcp(new EnhancedNumberValidator<int>(0, 10));
586  RCP<ArrayNumberValidator<int> > intArrayVali = rcp(new ArrayNumberValidator<int>(intVali));
587  TEST_ASSERT(intVali.get() == intArrayVali->getPrototype().get());
588  Array<int> intArray = tuple<int>(1,4,2,5);
589  TEST_NOTHROW(intList->set("int array param", intArray, "int array parameter", intArrayVali));
590  Array<int> intBadArray = tuple<int>(11,4,2,5);
591  TEST_THROW(intList->set("int bad array param", intBadArray, "int bad array parameter", intArrayVali),
592  Exceptions::InvalidParameterValue);
593  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", intArrayVali),
594  Exceptions::InvalidParameterType);
595 
596  /*
597  * Testing Short ArrayValidator.
598  */
599  RCP<ParameterList> shortList = rcp(new ParameterList("Short List"));
600  RCP<EnhancedNumberValidator<short> > shortVali =
601  rcp(new EnhancedNumberValidator<short>(0, 10));
602  RCP<ArrayNumberValidator<short> > shortArrayVali =
603  rcp(new ArrayNumberValidator<short>(shortVali));
604  TEST_ASSERT(shortVali.get() == shortArrayVali->getPrototype().get());
605  Array<short> shortArray = tuple<short>(1,4,2,5);
606  TEST_NOTHROW(shortList->set("short array param", shortArray, "short array parameter", shortArrayVali));
607  Array<short> shortBadArray = tuple<short>(11,4,2,5);
608  TEST_THROW(shortList->set("short bad array param", shortBadArray, "short bad array parameter", shortArrayVali),
609  Exceptions::InvalidParameterValue);
610  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", shortArrayVali),
611  Exceptions::InvalidParameterType);
612 
613  /*
614  * Testing Float ArrayValidator.
615  */
616  RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
617  RCP<EnhancedNumberValidator<float> > floatVali =
618  rcp(new EnhancedNumberValidator<float>(0.0, 10.0));
619  RCP<ArrayNumberValidator<float> > floatArrayVali =
620  rcp(new ArrayNumberValidator<float>(floatVali));
621  TEST_ASSERT(floatVali.get() == floatArrayVali->getPrototype().get());
622  Array<float> floatArray = tuple<float>(1.0,4.0,2.0,5.0);
623  TEST_NOTHROW(floatList->set("float array param", floatArray, "float array parameter", floatArrayVali));
624  Array<float> floatBadArray = tuple<float>(11.0,4.0,2.0,5.0);
625  TEST_THROW(floatList->set("float bad array param", floatBadArray, "float bad array parameter", floatArrayVali),
626  Exceptions::InvalidParameterValue);
627  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", floatArrayVali),
628  Exceptions::InvalidParameterType);
629 
630  /*
631  * Testing Double ArrayValidator.
632  */
633  RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
634  RCP<EnhancedNumberValidator<double> > doubleVali =
635  rcp(new EnhancedNumberValidator<double>(0.0, 10.0));
636  RCP<ArrayNumberValidator<double> > doubleArrayVali =
637  rcp(new ArrayNumberValidator<double>(doubleVali));
638  TEST_ASSERT(doubleVali.get() == doubleArrayVali->getPrototype().get());
639  Array<double> doubleArray = tuple<double>(1.0,4.0,2.0,5.0);
640  TEST_NOTHROW(doubleList->set("double array param", doubleArray, "double array parameter", doubleArrayVali));
641  Array<double> doubleBadArray = tuple<double>(11.0,4.0,2.0,5.0);
642  TEST_THROW(doubleList->set("double bad array param", doubleBadArray, "double bad array parameter", doubleArrayVali),
643  Exceptions::InvalidParameterValue);
644  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", doubleArrayVali),
645  Exceptions::InvalidParameterType);
646 
647  /*
648  * Testing FileName ArrayValidator.
649  */
650  RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
651  RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
652  RCP<ArrayFileNameValidator> arrayFileNameVali = rcp(new ArrayFileNameValidator(fileNameVali));
653  TEST_ASSERT(arrayFileNameVali->getPrototype().get() == fileNameVali.get());
654  Array<std::string> fileNameArray = tuple<std::string>("testFile.txt", "testFile2.txt", "testFile3.txt");
655  Array<std::string> fileNameBadArray = tuple<std::string>("doesnexist.txt", "testFile2.txt", "testFile3.txt");
656  TEST_NOTHROW(fileNameList->set("File name array", fileNameArray, "file name array parameter", arrayFileNameVali));
657  TEST_THROW(fileNameList->set("Bad File name array", fileNameBadArray, "bad file name array parameter", arrayFileNameVali),
658  Exceptions::InvalidParameterValue);
659  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", arrayFileNameVali),
660  Exceptions::InvalidParameterType);
661 }
662 
663 /*
664  * Testing TwoDArray Validators.
665  */
666 TEUCHOS_UNIT_TEST(Teuchos_Validators, twoDArrayValidators)
667 {
668 
669  /*
670  * Testing StringArrayValidator.
671  */
672  RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
673  Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
674  RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
675  RCP<TwoDArrayStringValidator> stringArrayVali =
676  rcp(new TwoDArrayStringValidator(stringVali));
677  TEST_ASSERT(stringVali.get() == stringArrayVali->getPrototype().get());
678  TwoDArray<std::string> stringArray(2,2);
679  stringArray(0,0) = "str2";
680  stringArray(0,1) = "str1";
681  stringArray(1,0) = "str3";
682  stringArray(1,1) = "str2";
683  TEST_NOTHROW(stringList->set("String Array Param", stringArray, "string array parameter", stringArrayVali));
684  TwoDArray<std::string> badStringArray(2,2);
685  badStringArray(0,0) = "str2";
686  badStringArray(0,1) = "str1";
687  badStringArray(1,0) = "str3";
688  badStringArray(1,1) = "not valid";
689  TEST_THROW(stringList->set("String Array Param", badStringArray, "string array parameter", stringArrayVali),
690  Exceptions::InvalidParameterValue);
691  TEST_THROW(stringList->set("Int param", 5, "int parameter", stringArrayVali),
692  Exceptions::InvalidParameterType);
693  TwoDArray<long> longArray(2,2);
694  longArray(0,0) = (long)5;
695  longArray(0,1) = (long)4;
696  longArray(1,0) = (long)9;
697  longArray(1,1) = (long)1;
698  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", stringArrayVali),
699  Exceptions::InvalidParameterType);
700 
701  /*
702  * Testing Int ArrayValidator.
703  */
704  RCP<ParameterList> intList = rcp(new ParameterList("Int List"));
705  RCP<EnhancedNumberValidator<int> > intVali = rcp(new EnhancedNumberValidator<int>(0, 10));
706  RCP<TwoDArrayNumberValidator<int> > intArrayVali =
707  rcp(new TwoDArrayNumberValidator<int>(intVali));
708  TEST_ASSERT(intVali.get() == intArrayVali->getPrototype().get());
709  TwoDArray<int> intArray(2,2);
710  intArray(0,0) = 1;
711  intArray(0,1) = 4;
712  intArray(1,0) = 2;
713  intArray(1,1) = 5;
714  TEST_NOTHROW(intList->set("int array param", intArray, "int array parameter", intArrayVali));
715  TwoDArray<int> intBadArray(2,2);
716  intBadArray(0,0) = 11;
717  intBadArray(0,1) = 4;
718  intBadArray(1,0) = 2;
719  intBadArray(1,1) = 5;
720  TEST_THROW(intList->set("int bad array param", intBadArray, "int bad array parameter", intArrayVali),
721  Exceptions::InvalidParameterValue);
722  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", intArrayVali),
723  Exceptions::InvalidParameterType);
724 
725  /*
726  * Testing Short ArrayValidator.
727  */
728  RCP<ParameterList> shortList = rcp(new ParameterList("Short List"));
729  RCP<EnhancedNumberValidator<short> > shortVali =
730  rcp(new EnhancedNumberValidator<short>(0, 10));
731  RCP<TwoDArrayNumberValidator<short> > shortArrayVali =
732  rcp(new TwoDArrayNumberValidator<short>(shortVali));
733  TEST_ASSERT(shortVali.get() == shortArrayVali->getPrototype().get());
734  TwoDArray<short> shortArray(2,2);
735  shortArray(0,0) = 1;
736  shortArray(0,1) = 4;
737  shortArray(1,0) = 2;
738  shortArray(1,1) = 5;
739  TEST_NOTHROW(shortList->set("short array param", shortArray, "short array parameter", shortArrayVali));
740  TwoDArray<short> shortBadArray(2,2);
741  shortBadArray(0,0) = 11;
742  shortBadArray(0,1) = 4;
743  shortBadArray(1,0) = 2;
744  shortBadArray(1,1) = 5;
745  TEST_THROW(shortList->set("short bad array param", shortBadArray, "short bad array parameter", shortArrayVali),
746  Exceptions::InvalidParameterValue);
747  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", shortArrayVali),
748  Exceptions::InvalidParameterType);
749 
750  /*
751  * Testing Float ArrayValidator.
752  */
753  RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
754  RCP<EnhancedNumberValidator<float> > floatVali =
755  rcp(new EnhancedNumberValidator<float>(0.0, 10.0));
756  RCP<TwoDArrayNumberValidator<float> > floatArrayVali =
757  rcp(new TwoDArrayNumberValidator<float>(floatVali));
758  TEST_ASSERT(floatVali.get() == floatArrayVali->getPrototype().get());
759  TwoDArray<float> floatArray(2,2);
760  floatArray(0,0) = 1.0;
761  floatArray(0,1) = 4.0;
762  floatArray(1,0) = 5.0;
763  floatArray(1,1) = 2.0;
764  TEST_NOTHROW(floatList->set("float array param", floatArray, "float array parameter", floatArrayVali));
765  TwoDArray<float> floatBadArray(2,2);
766  floatBadArray(0,0) = 11.0;
767  floatBadArray(0,1) = 4.0;
768  floatBadArray(1,0) = 5.0;
769  floatBadArray(1,1) = 2.0;
770  TEST_THROW(floatList->set("float bad array param", floatBadArray, "float bad array parameter", floatArrayVali),
771  Exceptions::InvalidParameterValue);
772  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", floatArrayVali),
773  Exceptions::InvalidParameterType);
774 
775  /*
776  * Testing Double ArrayValidator.
777  */
778  RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
779  RCP<EnhancedNumberValidator<double> > doubleVali =
780  rcp(new EnhancedNumberValidator<double>(0.0, 10.0));
781  RCP<TwoDArrayNumberValidator<double> > doubleArrayVali =
782  rcp(new TwoDArrayNumberValidator<double>(doubleVali));
783  TEST_ASSERT(doubleVali.get() == doubleArrayVali->getPrototype().get());
784  TwoDArray<double> doubleArray(2,2);
785  doubleArray(0,0) = 1.0;
786  doubleArray(0,1) = 4.0;
787  doubleArray(1,0) = 5.0;
788  doubleArray(1,1) = 2.0;
789  TEST_NOTHROW(doubleList->set("double array param", doubleArray, "double array parameter", doubleArrayVali));
790  TwoDArray<double> doubleBadArray(2,2);
791  doubleBadArray(0,0) = 11.0;
792  doubleBadArray(0,1) = 4.0;
793  doubleBadArray(1,0) = 5.0;
794  doubleBadArray(1,1) = 2.0;
795  TEST_THROW(doubleList->set("double bad array param", doubleBadArray, "double bad array parameter", doubleArrayVali),
796  Exceptions::InvalidParameterValue);
797  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", doubleArrayVali),
798  Exceptions::InvalidParameterType);
799 
800  /*
801  * Testing FileName ArrayValidator.
802  */
803  RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
804  RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
805  RCP<TwoDArrayFileNameValidator> arrayFileNameVali =
806  rcp(new TwoDArrayFileNameValidator(fileNameVali));
807  TEST_ASSERT(arrayFileNameVali->getPrototype().get() == fileNameVali.get());
808  TwoDArray<std::string> fileNameArray(2,2);
809  fileNameArray(0,0) = "testFile.txt";
810  fileNameArray(0,1) = "testFile2.txt";
811  fileNameArray(1,0) = "testFile3.txt";
812  fileNameArray(1,1) = "testFile.txt";
813  TwoDArray<std::string> fileNameBadArray(2,2);
814  fileNameBadArray(0,0) = "doesntexist.txt";
815  fileNameBadArray(0,1) = "testFile2.txt";
816  fileNameBadArray(1,0) = "testFile3.txt";
817  fileNameBadArray(1,1) = "testFile.txt";
818  TEST_NOTHROW(fileNameList->set("File name array", fileNameArray, "file name array parameter", arrayFileNameVali));
819  TEST_THROW(fileNameList->set("Bad File name array", fileNameBadArray, "bad file name array parameter", arrayFileNameVali),
820  Exceptions::InvalidParameterValue);
821  TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", arrayFileNameVali),
822  Exceptions::InvalidParameterType);
823 }
824 
825 
826 } // namespace Teuchos
827 
Teuchos_VerboseObject.hpp
Teuchos_StandardParameterEntryValidators.hpp
TEST_ASSERT
#define TEST_ASSERT(v1)
Assert the given statement is true.
Definition: Teuchos_LocalTestingHelpers.hpp:71
Teuchos::TwoDArrayStringValidator
Convience class for StringValidators that are to be applied to TwoDArrays.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2175
Teuchos::FileNameValidator::setFileMustExist
bool setFileMustExist(bool shouldFileExist)
Sets whether or not the validator requires the file to already exist.
Definition: Teuchos_StandardParameterEntryValidators.cpp:576
Teuchos::ArrayNumberValidator
Convience class for EnhancedNumberValidators that are to be applied to arrays.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2413
TEST_NOTHROW
#define TEST_NOTHROW(code)
Asserr that the statement &#39;code&#39; does not thrown any excpetions.
Definition: Teuchos_LocalTestingHelpers.hpp:219
Teuchos::ParameterList::set
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Set a parameter whose value has type T.
Definition: Teuchos_ParameterList.hpp:956
TEST_EQUALITY
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
Definition: Teuchos_LocalTestingHelpers.hpp:87
TEST_THROW
#define TEST_THROW(code, ExceptType)
Assert that the statement &#39;code&#39; throws the exception &#39;ExceptType&#39; (otherwise the test fails)...
Definition: Teuchos_LocalTestingHelpers.hpp:211
Teuchos::StringToIntegralParameterEntryValidator
Standard implementation of a ParameterEntryValidator that maps from a list of strings to an enum or i...
Definition: Teuchos_StandardParameterEntryValidators.hpp:92
Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes::allowString
AcceptedTypes & allowString(bool _allowString)
Set allow an std::string value or not.
Definition: Teuchos_StandardParameterEntryValidators.hpp:765
Teuchos::RCP::get
T * get() const
Get the raw C++ pointer to the underlying object.
Definition: Teuchos_RCP.hpp:397
Teuchos::ParameterEntry::getValue
T & getValue(T *ptr) const
Templated get method that uses the input pointer type to determine the type of parameter to return...
Definition: Teuchos_ParameterEntry.hpp:363
Teuchos::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(ConstNonconstObjectContainer, create)
Definition: ConstNonconstObjectContainer.cpp:48
Teuchos::TwoDArray
A thin wrapper around the Array class which causes it to be interpreted as a 2D Array.
Definition: Teuchos_TwoDArray.hpp:68
Teuchos::AbstractArrayValidator::getPrototype
RCP< const ValidatorType > getPrototype() const
Returns the prototype validator for this Array Validator.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2014
Teuchos::ArrayStringValidator
Convience class for StringValidators that are to be applied to arrays.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2364
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Definition: Teuchos_RCPDecl.hpp:1266
Teuchos_ParameterList.hpp
Templated Parameter List class.
Teuchos::EnhancedNumberTraits::defaultPrecision
static unsigned short defaultPrecision()
Gets the default precision with which the number type should be displayed.
Definition: Teuchos_StandardParameterEntryValidators.hpp:1256
Teuchos::TwoDArrayNumberValidator
Convience class for EnhancedNumberValidators that are to be applied to TwoDArray. ...
Definition: Teuchos_StandardParameterEntryValidators.hpp:2217
Teuchos_UnitTestHarness.hpp
Unit testing support.
Teuchos::BoolParameterEntryValidator
Standard implementation of a BoolParameterEntryValidator that accepts bool values (true/false) or str...
Definition: Teuchos_StandardParameterEntryValidators.hpp:627
Teuchos::TwoDArrayFileNameValidator
Convience class for FileNameValidators that are to be applied to TwoDArrays.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2196
Teuchos::ParameterList::validateParametersAndSetDefaults
void validateParametersAndSetDefaults(ParameterList const &validParamList, int const depth=1000)
Validate the parameters in this list given valid selections in the input list and set defaults for th...
Definition: Teuchos_ParameterList.cpp:606
Teuchos::ParameterList
A list of parameters of arbitrary type.
Definition: Teuchos_ParameterList.hpp:134
Teuchos::ParameterList::validateParameters
void validateParameters(ParameterList const &validParamList, int const depth=1000, EValidateUsed const validateUsed=VALIDATE_USED_ENABLED, EValidateDefaults const validateDefaults=VALIDATE_DEFAULTS_ENABLED) const
Validate the parameters in this list given valid selections in the input list.
Definition: Teuchos_ParameterList.cpp:415
Teuchos::StringValidator
A simple validator that only allows certain string values to be choosen or simply enforces that a par...
Definition: Teuchos_StandardParameterEntryValidators.hpp:1899
Teuchos::EnhancedNumberTraits::min
static T min()
Gets the minimum possible value the number type can take on.
Definition: Teuchos_StandardParameterEntryValidators.hpp:1242
TEST_COMPARE_ARRAYS
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
Definition: Teuchos_LocalTestingHelpers.hpp:172
Teuchos::EnhancedNumberTraits::defaultStep
static T defaultStep()
gets default amount a value of the number type should be incremented by when being utilizied in a UI...
Definition: Teuchos_StandardParameterEntryValidators.hpp:1251
Teuchos::EnhancedNumberTraits::max
static T max()
Gets the maximum possible value the number type can take on.
Definition: Teuchos_StandardParameterEntryValidators.hpp:1246
Teuchos::EnhancedNumberValidator
Class uesd to validate a particular type of number.
Definition: Teuchos_StandardParameterEntryValidators.hpp:1388
Teuchos::ArrayFileNameValidator
Convience class for FileNameValidators that are to be applied to arrays.
Definition: Teuchos_StandardParameterEntryValidators.hpp:2389
Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes::allowDouble
AcceptedTypes & allowDouble(bool _allowDouble)
Set allow a double value or not.
Definition: Teuchos_StandardParameterEntryValidators.hpp:762
Teuchos::RCP
Smart reference counting pointer class for automatic garbage collection.
Definition: Teuchos_RCPDecl.hpp:429
Teuchos::FileNameValidator::fileMustExist
bool fileMustExist() const
Gets the variable describing whether or not this validator wants the file that is specified to alread...
Definition: Teuchos_StandardParameterEntryValidators.cpp:566
Teuchos::AnyNumberParameterEntryValidator
Standard implementation of a ParameterEntryValidator that accepts numbers from a number of different ...
Definition: Teuchos_StandardParameterEntryValidators.hpp:733
Teuchos::ParameterList::getEntry
ParameterEntry & getEntry(const std::string &name)
Retrieves an entry with the name name.
Definition: Teuchos_ParameterList.hpp:1129
Generated on Thu Apr 25 2024 09:20:49 for Teuchos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5