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