Teuchos Package Browser (Single Doxygen Collection)  Version of the Day
Condition_Serialization_UnitTests.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 
42 #include "Teuchos_UnitTestHarness.hpp"
43 #include "Teuchos_VerboseObject.hpp"
44 #include "Teuchos_ParameterList.hpp"
45 #include "Teuchos_StandardConditions.hpp"
46 #include "Teuchos_ConditionXMLConverterDB.hpp"
47 #include "Teuchos_StandardDependencies.hpp"
48 #include "Teuchos_XMLParameterListCoreHelpers.hpp"
49 #include "Teuchos_XMLParameterListExceptions.hpp"
50 #include "Teuchos_StandardConditionXMLConverters.hpp"
51 #include "Teuchos_XMLConditionExceptions.hpp"
52 
53 #include "Teuchos_XMLParameterListTestHelpers.hpp"
54 
55 
56 namespace Teuchos{
57 
58 
62 TEUCHOS_UNIT_TEST(Teuchos_Conditions, StringConditionSerialization){
63  ConditionXMLConverterDB::printKnownConverters(out);
64  std::string paramName1 = "string param";
65  std::string paramName2 = "string param2";
66  std::string dependent1Name = "dependent1";
67  std::string dependent2Name = "dependent2";
68  std::string paramValue = "cheese";
69  StringCondition::ValueList conditionVal1 = tuple<std::string>("steve");
70  StringCondition::ValueList conditionVal2 =
71  tuple<std::string>("steve", "blah", "your face");
72  ParameterList testList("Condition Test List");
73  testList.set(paramName1, paramValue);
74  testList.set(paramName2, paramValue);
75  testList.set(dependent1Name, paramValue);
76  testList.set(dependent2Name, paramValue);
77  RCP<StringCondition> simpleStringCon =
78  rcp(new StringCondition(testList.getEntryRCP(paramName1), conditionVal1));
79  RCP<StringCondition> complexStringCon =
80  rcp(new StringCondition(
81  testList.getEntryRCP(paramName2), conditionVal2));
82 
83  RCP<ConditionVisualDependency> simpleConDep =
84  rcp(new ConditionVisualDependency(
85  simpleStringCon,
86  testList.getEntryRCP(dependent1Name)));
87 
88  RCP<ConditionVisualDependency> complexConDep =
89  rcp(new ConditionVisualDependency(
90  complexStringCon,
91  testList.getEntryRCP(dependent2Name)));
92 
93  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
94  depSheet1->addDependency(simpleConDep);
95  depSheet1->addDependency(complexConDep);
96 
97  writeParameterListToXmlOStream(testList, out, depSheet1);
98 
99  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
100  RCP<ParameterList> readinList =
101  writeThenReadPL(testList, depSheet1, depSheetIn);
102 
103  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
104  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
105 
106  RCP<ConditionVisualDependency> simpleReadInDep =
107  rcp_dynamic_cast<ConditionVisualDependency>(
108  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
109  TEST_EQUALITY(
110  simpleReadInDep->getCondition()->getTypeAttributeValue(),
111  DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
112  RCP<const StringCondition> simpleReadInCon =
113  rcp_dynamic_cast<const StringCondition>(simpleReadInDep->getCondition(), true);
114  TEST_ASSERT(nonnull(simpleReadInCon));
115 
116 
117  RCP<ConditionVisualDependency> complexReadInDep =
118  rcp_dynamic_cast<ConditionVisualDependency>(
119  *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
120  TEST_EQUALITY(
121  complexReadInDep->getCondition()->getTypeAttributeValue(),
122  DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
123  RCP<const StringCondition> complexReadInCon =
124  rcp_dynamic_cast<const StringCondition>(complexReadInDep->getCondition(), true);
125  TEST_ASSERT(nonnull(complexReadInCon));
126 
127 
128  TEST_COMPARE_ARRAYS(
129  simpleReadInCon->getValueList(), simpleStringCon->getValueList());
130  TEST_COMPARE_ARRAYS(
131  complexReadInCon->getValueList(), complexStringCon->getValueList());
132 
133 }
134 
135 TEUCHOS_UNIT_TEST(Teuchos_Conditions, BoolConditionSerialization){
136  ConditionXMLConverterDB::printKnownConverters(out);
137  std::string paramName1 = "bool param";
138  std::string dependent1Name = "dependent1";
139  bool paramValue = true;
140  std::string dependentValue = "hi there!";
141  ParameterList testList("Condition Test List");
142  testList.set(paramName1, paramValue);
143  testList.set(dependent1Name, dependentValue);
144  RCP<BoolCondition> boolCon =
145  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
146 
147  RCP<ConditionVisualDependency> boolConDep =
148  rcp(new ConditionVisualDependency(
149  boolCon,
150  testList.getEntryRCP(dependent1Name)));
151 
152  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
153  depSheet1->addDependency(boolConDep);
154 
155  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
156  RCP<ParameterList> readinList =
157  writeThenReadPL(testList, depSheet1, depSheetIn);
158 
159  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
160 
161  RCP<ConditionVisualDependency> simpleReadInDep =
162  rcp_dynamic_cast<ConditionVisualDependency>(
163  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
164  TEST_EQUALITY(
165  simpleReadInDep->getCondition()->getTypeAttributeValue(),
166  DummyObjectGetter<BoolCondition>::getDummyObject()->getTypeAttributeValue());
167  RCP<const BoolCondition> simpleReadInCon =
168  rcp_dynamic_cast<const BoolCondition>(simpleReadInDep->getCondition(), true);
169  TEST_ASSERT(nonnull(simpleReadInCon));
170 
171 }
172 
173 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(Teuchos_Conditions, NumberConditionSerialization, T){
174  ConditionXMLConverterDB::printKnownConverters(out);
175  std::string paramName1 = "T param";
176  std::string paramName2 = "T param 2";
177  std::string dependent1Name = "dependent1";
178  std::string dependent2Name = "dependent2";
179  T paramValue = ScalarTraits< T >::one();
180  T ten = 10 * ScalarTraits< T >::one();
181  std::string dependentValue = "hi there!";
182  ParameterList testList("Condition Test List");
183  testList.set(paramName1, paramValue);
184  testList.set(paramName2, paramValue);
185  testList.set(dependent1Name, dependentValue);
186  testList.set(dependent2Name, dependentValue);
187 
188  RCP<NumberCondition< T > > numberCon =
189  rcp(new NumberCondition< T >(testList.getEntryRCP(paramName1)));
190 
191  RCP<SubtractionFunction< T > > funcTester =
192  rcp(new SubtractionFunction< T >(ten));
193 
194  RCP<NumberCondition< T > > numberFuncCon =
195  rcp(new NumberCondition< T >(testList.getEntryRCP(paramName2), funcTester));
196 
197  RCP<ConditionVisualDependency> numberConDep =
198  rcp(new ConditionVisualDependency(
199  numberCon,
200  testList.getEntryRCP(dependent1Name)));
201 
202  RCP<ConditionVisualDependency> funcNumberConDep =
203  rcp(new ConditionVisualDependency(
204  numberFuncCon,
205  testList.getEntryRCP(dependent2Name)));
206 
207  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
208  depSheet1->addDependency(numberConDep);
209  depSheet1->addDependency(funcNumberConDep);
210 
211  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
212  RCP<ParameterList> readinList =
213  writeThenReadPL(testList, depSheet1, depSheetIn);
214 
215  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
216  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
217 
218 
219 
220 
221  RCP<ConditionVisualDependency> simpleReadInDep =
222  rcp_dynamic_cast<ConditionVisualDependency>(
223  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
224  TEST_EQUALITY(
225  simpleReadInDep->getCondition()->getTypeAttributeValue(),
226  DummyObjectGetter<NumberCondition< T > >::getDummyObject()->getTypeAttributeValue());
227  RCP<const NumberCondition< T > > simpleReadInCon =
228  rcp_dynamic_cast<const NumberCondition< T > >(simpleReadInDep->getCondition(), true);
229  TEST_ASSERT(nonnull(simpleReadInCon));
230 
231 
232  RCP<ConditionVisualDependency> funcReadInDep =
233  rcp_dynamic_cast<ConditionVisualDependency>(
234  *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
235  TEST_ASSERT(funcReadInDep != null);
236 
237  RCP<const NumberCondition< T > > funcReadInCon =
238  rcp_dynamic_cast<const NumberCondition< T > >(funcReadInDep->getCondition());
239 
240  TEST_ASSERT(funcReadInCon != null);
241 
242  RCP<const SubtractionFunction< T > > funcReadInFunc =
243  rcp_dynamic_cast<const SubtractionFunction< T > >(
244  funcReadInCon->getFunctionObject());
245  TEST_ASSERT(funcReadInFunc != null);
246  TEST_EQUALITY(
247  funcReadInFunc->getModifiyingOperand(),
248  funcTester->getModifiyingOperand());
249 
250 
251 }
252 
253 #define NUMBER_PARAM_TYPE_TEST( T ) \
254 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT(Teuchos_Conditions, NumberConditionSerialization, T )
255 
256 typedef unsigned int uint;
257 typedef unsigned short ushort;
258 typedef unsigned long ulong;
259 
260 NUMBER_PARAM_TYPE_TEST(int)
261 NUMBER_PARAM_TYPE_TEST(uint)
262 NUMBER_PARAM_TYPE_TEST(short)
263 NUMBER_PARAM_TYPE_TEST(ushort)
264 NUMBER_PARAM_TYPE_TEST(long)
265 NUMBER_PARAM_TYPE_TEST(ulong)
266 NUMBER_PARAM_TYPE_TEST(float)
267 NUMBER_PARAM_TYPE_TEST(double)
268 typedef long long int llint;
269 typedef unsigned long long int ullint;
270 NUMBER_PARAM_TYPE_TEST(llint)
271 NUMBER_PARAM_TYPE_TEST(ullint)
272 
273 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(Teuchos_Conditions, BoolLogicConditionSerialization, BinCondition){
274  ConditionXMLConverterDB::printKnownConverters(out);
275  std::string paramName1 = "bool param1";
276  std::string paramName2 = "bool param2";
277  std::string dependent1Name = "dependent1";
278  bool paramValue1 = true;
279  bool paramValue2 = false;
280  std::string dependentValue = "hi there!";
281  ParameterList testList("Condition Test List");
282  testList.set(paramName1, paramValue1);
283  testList.set(paramName2, paramValue2);
284  testList.set(dependent1Name, dependentValue);
285  RCP<BoolCondition> boolCon1 =
286  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
287  RCP<BoolCondition> boolCon2 =
288  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
289 
290  Condition::ConstConditionList conList =
291  tuple<RCP<const Condition> >(boolCon1, boolCon2);
292 
293  RCP< BinCondition > binCon = rcp(new BinCondition (conList));
294 
295  RCP<ConditionVisualDependency> binConDep =
296  rcp(new ConditionVisualDependency(
297  binCon,
298  testList.getEntryRCP(dependent1Name)));
299 
300  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
301  depSheet1->addDependency(binConDep);
302 
303  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
304  RCP<ParameterList> readinList =
305  writeThenReadPL(testList, depSheet1, depSheetIn);
306 
307  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
308  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
309 
310  RCP<ConditionVisualDependency> readInDep1 =
311  rcp_dynamic_cast<ConditionVisualDependency>(
312  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
313  RCP<ConditionVisualDependency> readInDep2 =
314  rcp_dynamic_cast<ConditionVisualDependency>(
315  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
316  TEST_EQUALITY(readInDep1.get(), readInDep1.get());
317  TEST_EQUALITY(
318  readInDep1->getCondition()->getTypeAttributeValue(),
319  DummyObjectGetter< BinCondition >::getDummyObject()->getTypeAttributeValue());
320  RCP<const BinCondition > readInCon =
321  rcp_dynamic_cast<const BinCondition >(readInDep1->getCondition(), true);
322  TEST_ASSERT(nonnull(readInCon));
323 
324  Condition::ConstConditionList readInConList = readInCon->getConditions();
325  TEST_ASSERT(readInConList.size() ==2);
326 
327 }
328 
329 #define BIN_CON_TEST( BinCondition ) \
330 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT(Teuchos_Conditions, BoolLogicConditionSerialization, BinCondition)
331 
332 BIN_CON_TEST(AndCondition)
333 BIN_CON_TEST(OrCondition)
334 BIN_CON_TEST(EqualsCondition)
335 
336 TEUCHOS_UNIT_TEST(Teuchos_Conditions, NotConditionSerialization){
337  ConditionXMLConverterDB::printKnownConverters(out);
338  std::string paramName1 = "bool param1";
339  std::string dependent1Name = "dependent1";
340  bool paramValue1 = true;
341  std::string dependentValue = "hi there!";
342  ParameterList testList("Condition Test List");
343  testList.set(paramName1, paramValue1);
344  testList.set(dependent1Name, dependentValue);
345  RCP<BoolCondition> boolCon1 =
346  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
347 
348 
349  RCP<NotCondition> notCon = rcp(new NotCondition(boolCon1));
350 
351  RCP<ConditionVisualDependency> notConDep =
352  rcp(new ConditionVisualDependency(
353  notCon,
354  testList.getEntryRCP(dependent1Name)));
355 
356  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
357  depSheet1->addDependency(notConDep);
358 
359  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
360  RCP<ParameterList> readinList =
361  writeThenReadPL(testList, depSheet1, depSheetIn);
362 
363  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
364 
365  RCP<ConditionVisualDependency> readInDep1 =
366  rcp_dynamic_cast<ConditionVisualDependency>(
367  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
368  TEST_EQUALITY(
369  readInDep1->getCondition()->getTypeAttributeValue(),
370  DummyObjectGetter<NotCondition>::getDummyObject()->getTypeAttributeValue());
371  RCP<const NotCondition> readInCon =
372  rcp_dynamic_cast<const NotCondition>(readInDep1->getCondition(), true);
373  TEST_ASSERT(nonnull(readInCon));
374 }
375 
376 TEUCHOS_UNIT_TEST(Teuchos_Conditions, ConditionSerializationExceptions){
377  ConditionXMLConverterDB::printKnownConverters(out);
378  RCP<DependencySheet> depSheet = rcp(new DependencySheet);
379 
380 
381  TEST_THROW(RCP<ParameterList> missingParameterList =
382  getParametersFromXmlFile(
383  "MissingParameterEntryDefinition.xml", depSheet),
384  MissingParameterEntryDefinitionException);
385 
386  RCP<ParameterEntry> notInListParam = rcp(new ParameterEntry(3.0));
387  RCP<NumberCondition<double> > doubleCon =
388  rcp(new NumberCondition<double>(notInListParam));
389 
390  NumberConditionConverter<double> doubleConConverter;
391  XMLParameterListWriter::EntryIDsMap emptyMap;
392  XMLObject toWriteTo;
393  TEST_THROW(doubleConConverter.fromConditiontoXML(doubleCon, emptyMap),
394  MissingParameterEntryDefinitionException);
395 
396  TEST_THROW(RCP<ParameterList> missingValuesList =
397  getParametersFromXmlFile(
398  "MissingValuesTag.xml", depSheet),
399  MissingValuesTagException);
400 
401 
402 }
403 
404 
405 } // namespace Teuchos
Teuchos::DummyObjectGetter::getDummyObject
static RCP< T > getDummyObject()
Retrieves a dummy object of type T.
Definition: Teuchos_DummyObjectGetter.hpp:60
Teuchos_ParameterList.hpp
Templated Parameter List class.
Teuchos::Array::size
size_type size() const
Definition: Teuchos_Array.hpp:1017
Teuchos::XMLObject
Representation of an XML data tree. XMLObject is a ref-counted handle to a XMLObjectImplem object,...
Definition: Teuchos_XMLObject.hpp:62
Teuchos_ConditionXMLConverterDB.hpp
A database for ConditionXMLConverters.
Teuchos::StringCondition
A String Condition is a Parameter Condition that evaluates whether or not a string parameter has take...
Definition: Teuchos_StandardConditions.hpp:144
Teuchos_XMLParameterListExceptions.hpp
A collection of Exceptions that can be potentially thrown when converting a ParameterList to and from...
Teuchos::NumberConditionConverter
An xml converter for NumberConditions The valid XML represntation for a NumberCondition is:
Definition: Teuchos_StandardConditionXMLConverters.hpp:353
Teuchos::ullint
unsigned long long int ullint
Definition: Condition_Serialization_UnitTests.cpp:269
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Definition: Teuchos_RCPDecl.hpp:1224
Teuchos::ParameterList::getEntryRCP
RCP< ParameterEntry > getEntryRCP(const std::string &name)
Retrieves the RCP for an entry with the name name if it exists.
Definition: Teuchos_ParameterList.hpp:1029
TEST_THROW
#define TEST_THROW(code, ExceptType)
Assert that the statement 'code' throws the exception 'ExceptType' (otherwise the test fails).
Definition: Teuchos_LocalTestingHelpers.hpp:198
Teuchos::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(ConstNonconstObjectContainer, create)
Definition: ConstNonconstObjectContainer.cpp:48
Teuchos::RCP
Smart reference counting pointer class for automatic garbage collection.
Definition: Teuchos_RCPDecl.hpp:429
Teuchos_UnitTestHarness.hpp
Unit testing support.
Teuchos::Array< std::string >
Teuchos::XMLParameterListWriter::EntryIDsMap
std::map< RCP< const ParameterEntry >, ParameterEntry::ParameterEntryID, RCPConstComp > EntryIDsMap
Definition: Teuchos_XMLParameterListWriter.hpp:73
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:831
Teuchos::MissingParameterEntryDefinitionException
Thrown when a referenced ParameterEntry can't be found.
Definition: Teuchos_XMLParameterListExceptions.hpp:240
Teuchos::MissingValuesTagException
Thrown when a StringConditon is missing it's Value tag.
Definition: Teuchos_XMLConditionExceptions.hpp:57
Teuchos::ConditionXMLConverterDB::printKnownConverters
static void printKnownConverters(std::ostream &out)
prints the xml tags associated with all known converters
Definition: Teuchos_ConditionXMLConverterDB.hpp:140
Teuchos::SubtractionFunction
A simple function object that subtracts a specififed value from the given arguement in the runFunctio...
Definition: Teuchos_StandardFunctionObjects.hpp:137
Teuchos::DependencySheet
A Dependency sheet keeps track of dependencies between various ParameterEntries.
Definition: Teuchos_DependencySheet.hpp:61
Teuchos::ScalarTraits::one
static T one()
Returns representation of one for this scalar type.
Definition: Teuchos_ScalarTraitsDecl.hpp:134
BIN_CON_TEST
#define BIN_CON_TEST(BinCondition)
Definition: Condition_Serialization_UnitTests.cpp:329
Teuchos::ushort
unsigned short ushort
Definition: Condition_Serialization_UnitTests.cpp:257
Teuchos::NumberCondition
A Number Condition is a Parameter Condition that evaluates whether or not a number parameter is great...
Definition: Teuchos_StandardConditions.hpp:260
Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(RCPNodeHandle, basicConstruct_owns_mem, T)
Definition: RCPNodeHandle_UnitTests.cpp:323
Teuchos::ConditionVisualDependency::getCondition
RCP< const Condition > getCondition() const
Gets the condition being used in this dependency.
Definition: Teuchos_StandardDependencies.cpp:257
Teuchos::DummyObjectGetter
Class for retrieving a dummy object of type T.
Definition: Teuchos_DummyObjectGetter.hpp:55
Teuchos_XMLParameterListCoreHelpers.hpp
Simple helper functions that make it easy to read and write XML to and from a parameterlist.
Teuchos_XMLConditionExceptions.hpp
A collection of Exceptions thrown when converting Conditions to and from XML.
Teuchos_StandardDependencies.hpp
A collection of standard dependencies.
Teuchos::DependencySheet::getDependenciesForParameter
RCP< const DepSet > getDependenciesForParameter(RCP< const ParameterEntry > dependee) const
Returns a set of all the dependencies associated with a particular dependee. If no dependencies with ...
Definition: Teuchos_DependencySheet.cpp:82
Teuchos::ConditionXMLConverter::fromConditiontoXML
XMLObject fromConditiontoXML(const RCP< const Condition > condition, const XMLParameterListWriter::EntryIDsMap &entryIDsMap) const
Converters a given ParameterEntryValidator to XML.
Definition: Teuchos_ConditionXMLConverter.cpp:56
NUMBER_PARAM_TYPE_TEST
#define NUMBER_PARAM_TYPE_TEST(T)
Definition: Condition_Serialization_UnitTests.cpp:253
Teuchos::NotCondition
A Not condition returns the result of performing a logical NOT on a given condition.
Definition: Teuchos_StandardConditions.hpp:752
Teuchos::RCP::get
T * get() const
Get the raw C++ pointer to the underlying object.
Definition: Teuchos_RCP.hpp:363
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::writeThenReadPL
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< ParameterList > writeThenReadPL(ParameterList &myList)
Write a parameter list to xml and then read that xml back in via a string. The intent of this functio...
Definition: Teuchos_XMLParameterListTestHelpers.cpp:48
Teuchos::nonnull
bool nonnull(const std::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
Definition: Teuchos_RCPStdSharedPtrConversionsDecl.hpp:159
Teuchos::ParameterList
A list of parameters of arbitrary type.
Definition: Teuchos_ParameterList.hpp:132
Teuchos_XMLParameterListTestHelpers.hpp
Teuchos::ulong
unsigned long ulong
Definition: Condition_Serialization_UnitTests.cpp:258
Teuchos
Definition: Teuchos_AbstractFactory.hpp:47
Teuchos::ConditionVisualDependency
A condition visual dependency says the following about the relationship between elements in a Paramet...
Definition: Teuchos_StandardDependencies.hpp:529
Teuchos::DependencySheet::addDependency
void addDependency(RCP< Dependency > dependency)
Adds a dependency to the sheet.
Definition: Teuchos_DependencySheet.cpp:58
Teuchos::uint
unsigned int uint
Definition: Condition_Serialization_UnitTests.cpp:256
Teuchos::TEST_EQUALITY
TEST_EQUALITY(rcp_dynamic_cast< const EnhancedNumberValidator< double > >(castedDep1->getValuesAndValidators().find("val1") ->second, true) ->getMax(), double1Vali->getMax())
Teuchos::TEST_ASSERT
TEST_ASSERT(castedDep1->getValuesAndValidators().size()==2)
Teuchos::StringCondition::getValueList
const ValueList & getValueList() const
Returns the value list being used with this StringCondition.
Definition: Teuchos_StandardConditions.hpp:202
Teuchos::ParameterEntry
This object is held as the "value" in the Teuchos::ParameterList std::map.
Definition: Teuchos_ParameterEntry.hpp:67
Teuchos::BoolCondition
A Bool Condition is a Parameter Condition that evaluates whether or not a Boolean parameter is ture.
Definition: Teuchos_StandardConditions.hpp:374
Teuchos_StandardConditionXMLConverters.hpp
A collection of standard ConditionXMLConverters.
Teuchos_VerboseObject.hpp
Teuchos_StandardConditions.hpp
Standard Conditions to be used.
Teuchos::llint
long long int llint
Definition: Condition_Serialization_UnitTests.cpp:268
Generated by   doxygen 1.8.16