// Here we're checking:
// 1. That we can set a parameter list on it and it uses it and then we can
// unset it and it goes back to using the valid parameter list.
// 1a. We get back the same parameter list we set
// 2. In debug mode, the parameter list is validated when unsetParameterList
// is called.
TEUCHOS_UNIT_TEST( Teuchos_ObjectBuilder, unsetParameterList) {
RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
const RCP<ParameterList> pl = parameterList();
pl->set("Object Type","None");
ob->setParameterList(pl);
RCP<Foo> foo = ob->create();
TEST_EQUALITY_CONST( is_null(foo), true );
RCP<ParameterList> newPL = ob->unsetParameterList();
TEST_EQUALITY_CONST( pl.get(), newPL.get() ); // 1a.
foo = ob->create();
const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
TEST_EQUALITY_CONST( is_null(fooA), false ); // 1.
ob->setParameterList(pl);
pl->set("Hello","World");
newPL = null;
#ifdef TEUCHOS_DEBUG
TEST_THROW( newPL = ob->unsetParameterList(), std::logic_error ); // 2.
TEST_EQUALITY_CONST( is_null(newPL), true );
TEST_THROW( ob = null, std::logic_error );
#else // TEUCHOS_DEBUG
TEST_NOTHROW( newPL = ob->unsetParameterList() );
TEST_EQUALITY_CONST( pl.get(), newPL.get() ); // 1a.
TEST_NOTHROW( ob = null );
#endif // TEUCHOS_DEBUG
}
TEUCHOS_UNIT_TEST( Rythmos_StepperBuilder, setParameterList ) {
RCP<ParameterList> pl = Teuchos::parameterList();
RCP<StepperBuilder<double> > builder = stepperBuilder<double>();
TEST_NOTHROW(builder->setParameterList(pl));
// NOTE (mfh 21 Sep 2015) It turns out that the problem with GCC
// 4.8.x mentioned below, is also a problem with GCC 5.2. I changed
// the #if condition accordingly and now the test passes for me.
// Test that StepperBuilder validates its parameter list
#if !( (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ == 8) )
// For some reason, GCC 4.8.x has a problem with catching exeptions when you
// set an RCP to null. For for GCC 4.8 we will skip all of these tests
// below.
pl->set("Hello","World"); // This changes the parameter list inside the builder.
TEST_THROW(builder->setParameterList(pl), std::logic_error);
#ifdef TEUCHOS_DEBUG
// This throws because we changed the internal parameter list to an invalid one.
TEST_THROW(builder = Teuchos::null, std::logic_error);
#else // TEUCHOS_DEBUG
TEST_NOTHROW(builder = Teuchos::null );
#endif // TEUCHOS_DEBUG
builder = stepperBuilder<double>();
pl = Teuchos::parameterList();
pl->set("Hello","World");
TEST_THROW(builder->setParameterList(pl), std::logic_error); // invalid parameterlist
TEST_NOTHROW(builder = Teuchos::null); // invalid parameter list not stored
#endif // __GNUC__ version
}
// The following happens at construction:
// 1. initializeDefaults_ is called
// a) object_name_ = "Object"
// b) objectType_name_ = "Object Type"
// c) defaultObject_ = "None"
// d) validObjectNames_ just has "None"
TEUCHOS_UNIT_TEST( Teuchos_ObjectBuilder, constructor) {
RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
TEST_EQUALITY_CONST( ob->getObjectName(), "None" );
TEST_EQUALITY_CONST( ob->create(), null );
RCP<const ParameterList> pl;
TEST_NOTHROW( pl = ob->getValidParameters() );
TEST_EQUALITY_CONST( pl->get<std::string>("Object Type"), "None" );
TEST_NOTHROW( ob = null );
}
// triangle tests
TEUCHOS_UNIT_TEST(tGeometricFieldPattern, test2d)
{
out << note << std::endl;
// basis to build patterns from
const int order = 6;
RCP<Intrepid2::Basis<PHX::Device,double,double> > basis = rcp(new Intrepid2::Basis_HGRAD_QUAD_Cn_FEM<PHX::Device,double,double>(order));
RCP<const FieldPattern> pattern = rcp(new Intrepid2FieldPattern(basis));
std::vector<RCP<const FieldPattern> > patterns;
std::vector<int> indices;
{
// test unbuilt exceptions
GeometricAggFieldPattern gfp;
TEST_THROW(gfp.getDimension(),std::logic_error);
TEST_THROW(gfp.getSubcellCount(0),std::logic_error);
TEST_THROW(gfp.getSubcellIndices(0,0),std::logic_error);
TEST_THROW(gfp.getSubcellClosureIndices(0,0,indices),std::logic_error);
}
{
patterns.clear();
patterns.push_back(pattern);
GeometricAggFieldPattern gfp;
gfp.buildPattern(patterns);
TEST_NOTHROW(gfp.getDimension());
TEST_NOTHROW(gfp.getSubcellCount(0));
TEST_NOTHROW(gfp.getSubcellIndices(0,0));
TEST_THROW(gfp.getSubcellClosureIndices(0,0,indices),std::logic_error);
TestFieldPattern tfp;
tfp.cellTopo = shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4> >());
tfp.subcellIndices.resize(3); // 3 geometric types: vertex, edge, interior
// vertex
tfp.subcellIndices[0].resize(4);
tfp[0][0].push_back(0); tfp[0][1].push_back(1); tfp[0][2].push_back(2); tfp[0][3].push_back(3);
// edge and interior
tfp.subcellIndices[1].resize(4);
tfp.subcellIndices[2].resize(1);
if (order > 1) {
tfp[1][0].push_back(4); tfp[1][1].push_back(5); tfp[1][2].push_back(6); tfp[1][3].push_back(7);
tfp[2][0].push_back(8);
}
TEST_ASSERT(gfp.equals(tfp));
}
}
TEUCHOS_UNIT_TEST(Ifpack2Parameters, Test0)
{
//we are now in a class method declared by the above macro, and
//that method has these input arguments:
//Teuchos::FancyOStream& out, bool& success
Teuchos::ParameterList params;
params.set("fact: iluk level-of-fill", (int) 2);
Teuchos::ParameterList validparams;
TEST_NOTHROW(Ifpack2::getValidParameters(validparams));
params.validateParameters(validparams);
int level_of_fill = 0;
//call getParameter with a wrong name:
Ifpack2::getParameter(params, "level-of-fill", level_of_fill);
TEST_EQUALITY(level_of_fill, 0)
//call getParameter with a valid name:
Ifpack2::getParameter(params, "fact: iluk level-of-fill", level_of_fill);
TEST_EQUALITY(level_of_fill, 2)
}
TEUCHOS_UNIT_TEST( Rythmos_ThetaStepper, createImplicitEuler) {
// Model
RCP<SinCosModel> model = sinCosModel(true);
RCP<ParameterList> modelPL =
Teuchos::getParametersFromXmlFile("modelParams.xml");
modelPL->validateParametersAndSetDefaults(*model->getValidParameters());
Thyra::ModelEvaluatorBase::InArgs<double> ic = model->getNominalValues();
// Solver
RCP<TimeStepNonlinearSolver<double> > solver =
timeStepNonlinearSolver<double>();
// test reading params from .xml file
RCP<ParameterList> stepperParamList =
Teuchos::getParametersFromXmlFile("implicitEulerParams.xml");
// Stepper
RCP<ThetaStepper<double> > stepper =
thetaStepper<double>(model, solver, stepperParamList);
TEST_ASSERT( !is_null(stepper) );
stepper->setInitialCondition(ic);
// for testing purposes only
stepper->setVerbLevel(Teuchos::VERB_EXTREME);
double dt = 1.0;
double dt_taken = 0.0;
TEST_NOTHROW( dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED) );
TEST_EQUALITY_CONST( dt_taken, dt );
}
TEUCHOS_UNIT_TEST( XMLParameterListReader, XMLDuplicatedSublistsBackwardsCompatible )
{
FileInputSource xmlFile(filename);
XMLObject xmlParams = xmlFile.getObject();
XMLParameterListReader xmlPLReader;
TEST_EQUALITY_CONST( xmlPLReader.getAllowsDuplicateSublists(), true );
TEST_NOTHROW( xmlPLReader.toParameterList(xmlParams) );
}
// This function does several things.
// 1. It creates the validParameterList whenever it is deleted [already tested in setObjectFactory]
// 2. It creates the objectValidator
// 3. It adds a docstring to the "Object Type" parameter in the parameter list [already tested in setNames]
// 4. It fills the parameter list out with the valid parameteres for each object it can create
TEUCHOS_UNIT_TEST( Teuchos_ObjectBuilder, getValidParameters) {
{
const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
const RCP<ParameterList> pl = parameterList();
pl->set("Object Type","Foo B");
TEST_THROW( ob->setParameterList(pl), std::logic_error ); // 2.
}
{
const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo B");
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo C");
const RCP<ParameterList> validPL = parameterList();
validPL->set("Object Type","Foo C");
validPL->sublist("Foo A").set("String","A");
validPL->sublist("Foo B").set("String","B");
validPL->sublist("Foo C").set("String","C");
Array<std::string> validObjectNames;
validObjectNames.push_back("None");
validObjectNames.push_back("Foo A");
validObjectNames.push_back("Foo B");
validObjectNames.push_back("Foo C");
const RCP<const StringToIntegralParameterEntryValidator<int> >
objectValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
validObjectNames,"Object Type"
)
);
validPL->set(
"Object Type","Foo C"
,(std::string("Determines the type of Object object that will be built.\n")
+ "The parameters for each Object Type are specified in this sublist"
).c_str()
,objectValidator
);
const RCP<const ParameterList> pl = ob->getValidParameters();
TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
validPL->set("Object Type","Foo A");
TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
validPL->set("Object Type","Foo B");
TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
validPL->set("Object Type","None");
TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
}
}
TEUCHOS_UNIT_TEST( Rythmos_ThetaStepper, createTrapezoid) {
// Model
RCP<SinCosModel> model = sinCosModel(true);
RCP<ParameterList> modelPL =
Teuchos::getParametersFromXmlFile("modelParams.xml");
modelPL->validateParametersAndSetDefaults(*model->getValidParameters());
Thyra::ModelEvaluatorBase::InArgs<double> ic = model->getNominalValues();
// Solver
RCP<TimeStepNonlinearSolver<double> > solver =
timeStepNonlinearSolver<double>();
// test generating internal param list
RCP<ParameterList> stepperParamList = Teuchos::parameterList();
ParameterList& pl = stepperParamList->sublist("Step Control Settings");
pl.set("Theta Stepper Type", "Trapezoid");
//RCP<ParameterList> stepperParamList =
// Teuchos::getParametersFromXmlFile("trapezoidParams.xml");
// Stepper
RCP<ThetaStepper<double> > stepper =
thetaStepper<double>(model, solver, stepperParamList);
TEST_ASSERT( !is_null(stepper) );
stepper->setInitialCondition(ic);
// for testing purposes only
stepper->setVerbLevel(Teuchos::VERB_EXTREME);
double dt = 1.0;
double dt_taken = 0.0;
TEST_NOTHROW( dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED) );
TEST_EQUALITY_CONST( dt_taken, dt );
// take extra steps to verify 2nd order method is working
TEST_NOTHROW( dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED) );
TEST_EQUALITY_CONST( dt_taken, dt );
TEST_NOTHROW( dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED) );
TEST_EQUALITY_CONST( dt_taken, dt );
}
// We shouldn't be able to set two factories with the same name.
TEUCHOS_UNIT_TEST( Teuchos_ObjectBuilder, setObjectFactory_bad ) {
{
const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
// ObjectBuilder will let you add the object, but will not throw until getValidParameters is called
#ifdef TEUCHOS_DEBUG
TEST_THROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A"), std::logic_error );
#else // TEUCHOS_DEBUG
TEST_NOTHROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A") );
TEST_THROW( ob->getValidParameters(), std::logic_error );
#endif // TEUCHOS_DEBUG
}
{
const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
TEST_NOTHROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"New Foo A") );
TEST_NOTHROW( ob->getValidParameters() );
}
}
// Here we test
// 1. That it returns a null RCP before we give it a parameter list.
// 2. That we can set up a valid parameter list, give it to the ObjectBuilder, and get it back out.
TEUCHOS_UNIT_TEST( Teuchos_ObjectBuilder, getParameterList) {
const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
const RCP<const ParameterList> pl = ob->getParameterList();
TEST_EQUALITY_CONST( is_null(pl), true ); // 1.
const RCP<ParameterList> nonconstPL = parameterList();
nonconstPL->set("Object Type","None");
TEST_NOTHROW( ob->setParameterList(nonconstPL) );
{
const RCP<const ParameterList> newPL = ob->getParameterList();
TEST_EQUALITY_CONST( nonconstPL.get(), newPL.get() ); // 2.
}
}
TEUCHOS_UNIT_TEST(equation_set, steady_state)
{
Teuchos::RCP<Teuchos::ParameterList> p = Teuchos::parameterList();
p->set("Type","Energy");
p->set("Prefix","ION_");
p->set("Model ID","solid");
p->set("Basis Type","HGrad");
p->set("Basis Order",1);
int default_integration_order = 1;
int num_cells = 20;
panzer::CellData cell_data(num_cells,Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >())));
Teuchos::RCP<panzer::EquationSet_TemplateManager<panzer::Traits> > eq_set;
user_app::MyFactory my_factory;
Teuchos::RCP<panzer::GlobalData> global_data = panzer::createGlobalData();
TEST_NOTHROW(eq_set = my_factory.buildEquationSet(p, default_integration_order, cell_data, global_data, false));
}
TEUCHOS_UNIT_TEST( Rythmos_BackwardEulerStepper, checkConsistentState ) {
{
RCP<SinCosModel> model = sinCosModel(true);
Thyra::ModelEvaluatorBase::InArgs<double> model_ic = model->getNominalValues();
RCP<Thyra::NonlinearSolverBase<double> > neSolver = timeStepNonlinearSolver<double>();
RCP<BackwardEulerStepper<double> > stepper = backwardEulerStepper<double>(model,neSolver);
stepper->setInitialCondition(model_ic);
double dt = 0.1;
double dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED);
TEST_ASSERT( dt == dt_taken );
RCP<const MomentoBase<double> > momento = stepper->getMomento();
TEST_THROW(stepper->setMomento(momento.ptr(),Teuchos::null,Teuchos::null), std::logic_error);
TEST_THROW(stepper->setMomento(momento.ptr(),model,Teuchos::null), std::logic_error);
TEST_THROW(stepper->setMomento(momento.ptr(),Teuchos::null,neSolver), std::logic_error);
TEST_NOTHROW(stepper->setMomento(momento.ptr(),model,neSolver));
}
{
// Initialize a valid non-const momento:
RCP<BackwardEulerStepperMomento<double> > momento;
{
RCP<SinCosModel> model = sinCosModel(true);
Thyra::ModelEvaluatorBase::InArgs<double> model_ic = model->getNominalValues();
RCP<Thyra::NonlinearSolverBase<double> > neSolver = timeStepNonlinearSolver<double>();
RCP<BackwardEulerStepper<double> > stepper = backwardEulerStepper<double>(model,neSolver);
stepper->setInitialCondition(model_ic);
double dt = 0.1;
double dt_taken = stepper->takeStep(dt,STEP_TYPE_FIXED);
TEST_ASSERT( dt == dt_taken );
RCP<const MomentoBase<double> > m = stepper->getMomento();
RCP<const BackwardEulerStepperMomento<double> > beMomento = Teuchos::rcp_dynamic_cast<const BackwardEulerStepperMomento<double> >(m,true);
momento = Teuchos::rcp_dynamic_cast<BackwardEulerStepperMomento<double> >(beMomento->clone(),true);
}
{
// Check if isInitialized_ == true, but
// model_ = null or solver = null or haveInitialCondition_ = false or interpolator = null
RCP<BackwardEulerStepperMomento<double> > m = Teuchos::rcp_dynamic_cast<BackwardEulerStepperMomento<double> >(momento->clone(),true);
RCP<BackwardEulerStepper<double> > stepper = backwardEulerStepper<double>();
RCP<SinCosModel> model = sinCosModel(true);
RCP<Thyra::NonlinearSolverBase<double> > neSolver = timeStepNonlinearSolver<double>();
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
TEST_THROW(stepper->setMomento(m.ptr(),Teuchos::null,neSolver),std::logic_error);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
TEST_THROW(stepper->setMomento(m.ptr(),model,Teuchos::null),std::logic_error);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
m->set_haveInitialCondition(false);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_haveInitialCondition(true);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
RCP<InterpolatorBase<double> > interp = m->get_interpolator();
m->set_interpolator(Teuchos::null);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_interpolator(interp);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
}
{
// Check if haveInitialCondition_ == true, but
// t_ == nan or
// t_old_ == nan or
// scaled_x_old == null or
// x_dot_old == null or
// x == null or
// x_dot == null
typedef Teuchos::ScalarTraits<double> ST;
RCP<BackwardEulerStepperMomento<double> > m = Teuchos::rcp_dynamic_cast<BackwardEulerStepperMomento<double> >(momento->clone(),true);
RCP<BackwardEulerStepper<double> > stepper = backwardEulerStepper<double>();
RCP<SinCosModel> model = sinCosModel(true);
RCP<Thyra::NonlinearSolverBase<double> > neSolver = timeStepNonlinearSolver<double>();
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
double t = m->get_t();
m->set_t(ST::nan());
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_t(t);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
double t_old = m->get_t_old();
m->set_t_old(ST::nan());
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_t_old(t_old);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
RCP<VectorBase<double> > scaled_x_old = m->get_scaled_x_old();
m->set_scaled_x_old(Teuchos::null);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_scaled_x_old(scaled_x_old);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
RCP<VectorBase<double> > x_dot_old = m->get_x_dot_old();
m->set_x_dot_old(Teuchos::null);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_x_dot_old(x_dot_old);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
RCP<VectorBase<double> > x = m->get_x();
m->set_x(Teuchos::null);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_x(x);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
RCP<VectorBase<double> > x_dot = m->get_x_dot();
m->set_x_dot(Teuchos::null);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_x_dot(x_dot);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
}
{
// Check that if numSteps_ > 0 then isInitialized_ == true and haveInitialCondition_ == true
RCP<BackwardEulerStepperMomento<double> > m = Teuchos::rcp_dynamic_cast<BackwardEulerStepperMomento<double> >(momento->clone(),true);
TEST_ASSERT( m->get_numSteps() == 1 );
RCP<BackwardEulerStepper<double> > stepper = backwardEulerStepper<double>();
RCP<SinCosModel> model = sinCosModel(true);
RCP<Thyra::NonlinearSolverBase<double> > neSolver = timeStepNonlinearSolver<double>();
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
m->set_isInitialized(false);
TEST_THROW(stepper->setMomento(m.ptr(),model,neSolver),std::logic_error);
m->set_isInitialized(true);
TEST_NOTHROW(stepper->setMomento(m.ptr(),model,neSolver));
}
}
}
/**
* Test all the validator dependencies.
*/
TEUCHOS_UNIT_TEST(Teuchos_Dependencies, testValiDeps){
RCP<ParameterList> My_deplist = rcp(new ParameterList);
RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
/*
* Testing StringValidatorDependency
*/
RCP<StringToIntegralParameterEntryValidator<int> >
stringFoodTypeValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "Cheese", "Soda", "Chips" )
,"Food Type"
)
);
RCP<StringToIntegralParameterEntryValidator<int> >
cheeseValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "Swiss", "American", "Super Awesome Cheese" )
,"Food Selector"
)
);
RCP<StringToIntegralParameterEntryValidator<int> >
sodaValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "Pepsi", "Coke", "Kurtis Cola", "Bad Cola" )
,"Food Selector"
)
);
RCP<StringToIntegralParameterEntryValidator<int> >
chipsValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "Lays", "Doritos", "Kurtis Super Awesome Brand" )
,"Food Selector"
)
);
StringValidatorDependency::ValueToValidatorMap testValidatorMap1;
testValidatorMap1["Cheese"] = cheeseValidator;
testValidatorMap1["Soda"] = sodaValidator;
testValidatorMap1["Chips"] = chipsValidator;
ParameterList stringValiDepList = My_deplist->sublist(
"String Validator Dependency", false,
"String Validator Dependency testing list.");
stringValiDepList.set(
"Food Selector", "Swiss", "select the food you want", cheeseValidator);
stringValiDepList.set(
"Food Type",
"Cheese",
"String Validator Dependency Tester",
stringFoodTypeValidator);
RCP<StringValidatorDependency>
stringValiDep = rcp(
new StringValidatorDependency(
stringValiDepList.getEntryRCP("Food Type"),
stringValiDepList.getEntryRCP("Food Selector"),
testValidatorMap1,
cheeseValidator
)
);
depSheet1->addDependency(stringValiDep);
TEST_NOTHROW(stringValiDepList.validateParameters(stringValiDepList));
TEST_ASSERT(depSheet1->hasDependents(
stringValiDepList.getEntryRCP("Food Type")));
RCP<const DependencySheet::DepSet> stringValiDepSet =
depSheet1->getDependenciesForParameter(
stringValiDepList.getEntryRCP("Food Type"));
TEST_ASSERT(stringValiDepSet->size() == 1);
stringValiDepList.set("Food Type","Soda");
stringValiDep->evaluate();
TEST_ASSERT(stringValiDepList.getEntry("Food Selector").validator()
==
sodaValidator);
TEST_THROW(stringValiDepList.validateParameters(stringValiDepList),
Exceptions::InvalidParameterValue);
stringValiDepList.set("Food Selector", "Pepsi");
TEST_NOTHROW(stringValiDepList.validateParameters(stringValiDepList));
/*
* Tesing some different aspects of the StringValidatorDependency
*/
ParameterList
stringValiDepList2 = My_deplist->sublist(
"String Validator Dependency (other validators)",
false,
"String validator testing"
);
RCP<StringToIntegralParameterEntryValidator<int> >
stringRangeValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "1-10", "10-33", "50-60" ),
"Range selector"
)
);
RCP<EnhancedNumberValidator<int> > range110Vali =
rcp(new EnhancedNumberValidator<int>(1,10));
RCP<EnhancedNumberValidator<int> > range1033Vali =
rcp(new EnhancedNumberValidator<int>(10,33));
RCP<EnhancedNumberValidator<int> > range5060Vali =
rcp(new EnhancedNumberValidator<int>(50,60));
stringValiDepList2.set("Range selector", "1-10",
"selects the range to validate", stringRangeValidator);
StringValidatorDependency::ValueToValidatorMap rangeValidatorMap1;
rangeValidatorMap1["1-10"] = range110Vali;
rangeValidatorMap1["10-33"] = range1033Vali;
rangeValidatorMap1["50-60"] = range5060Vali;
stringValiDepList2.set(
"RangeValue", 3, "the value of the range", range110Vali);
RCP<StringValidatorDependency>
stringValiDep2 = RCP<StringValidatorDependency>(
new StringValidatorDependency(
stringValiDepList2.getEntryRCP("Range selector"),
stringValiDepList2.getEntryRCP("RangeValue"),
rangeValidatorMap1,
range110Vali
)
);
depSheet1->addDependency(stringValiDep2);
TEST_NOTHROW(stringValiDepList2.validateParameters(stringValiDepList2));
TEST_ASSERT(depSheet1->hasDependents(
stringValiDepList2.getEntryRCP("Range selector")));
RCP<const DependencySheet::DepSet> stringValiDepSet2 =
depSheet1->getDependenciesForParameter(
stringValiDepList2.getEntryRCP("Range selector"));
TEST_ASSERT(stringValiDepSet2->size() == 1);
stringValiDepList2.set("Range selector","50-60");
stringValiDep2->evaluate();
TEST_ASSERT(stringValiDepList2.getEntry("RangeValue").validator()
==
range5060Vali);
TEST_THROW(stringValiDepList2.validateParameters(stringValiDepList2),
Exceptions::InvalidParameterValue);
stringValiDepList2.set("RangeValue", 55);
TEST_NOTHROW(stringValiDepList2.validateParameters(stringValiDepList2));
/*
* Testing the BoolValidatorDependency.
*/
ParameterList
boolValidatorDepList = My_deplist->sublist(
"Bool Validator Dependency List",
false,
"Bool Validator Dependency testing list."
);
boolValidatorDepList.set("Use Validator?",
true, "truns the validator on and off");
RCP<EnhancedNumberValidator<int> > basicVali =
rcp(new EnhancedNumberValidator<int>(1,10));
RCP<EnhancedNumberValidator<int> > basicVali2 =
rcp(new EnhancedNumberValidator<int>());
boolValidatorDepList.set("do I have a validator?",
4, "does it have a validator?", basicVali);
RCP<BoolValidatorDependency>
boolValiDep = RCP<BoolValidatorDependency>(
new BoolValidatorDependency(
boolValidatorDepList.getEntryRCP("Use Validator?"),
boolValidatorDepList.getEntryRCP("do I have a validator?"),
basicVali,
basicVali2
)
);
depSheet1->addDependency(boolValiDep);
TEST_ASSERT(depSheet1->hasDependents(
boolValidatorDepList.getEntryRCP("Use Validator?")));
TEST_ASSERT(
boolValidatorDepList.getEntry("do I have a validator?").validator()
==
basicVali);
TEST_NOTHROW(
boolValidatorDepList.validateParameters(boolValidatorDepList));
RCP<const DependencySheet::DepSet> boolValiDepSet =
depSheet1->getDependenciesForParameter(boolValidatorDepList.getEntryRCP(
"Use Validator?"));
TEST_ASSERT(boolValiDepSet->size() == 1);
boolValidatorDepList.set("Use Validator?",false);
boolValiDep->evaluate();
TEST_ASSERT(
boolValidatorDepList.getEntry("do I have a validator?").validator()
==
basicVali2);
/*
* Testing the RangeValidatorDependency
*/
RCP<StringToIntegralParameterEntryValidator<int> >
lowTempCheeseValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>( "PepperJack", "Swiss", "American" ),
"Cheese to Fondue"
)
);
RCP<StringToIntegralParameterEntryValidator<int> >
highTempCheeseValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>(
"Munster", "Provalone", "Kurtis Super Awesome Cheese"),
"Cheese to Fondue"
)
);
RCP<StringToIntegralParameterEntryValidator<int> >
defaultCheeseValidator = rcp(
new StringToIntegralParameterEntryValidator<int>(
tuple<std::string>(
"Other cheese", "other cheese 1", "other cheese 3"),
"Cheese to Fondue"
)
);
ParameterList&
rangeValidatorDepList = My_deplist->sublist(
"Range Validator Dependency List",
false,
"Range Validator Dependency testing list.\nWorking June 27th 2009"
);
rangeValidatorDepList.set(
"Temperature",101.0, "The temperature of the fondue");
rangeValidatorDepList.set(
"Cheese to Fondue", "Swiss",
"The cheese we'll be using in our fondue pot.", lowTempCheeseValidator);
RangeValidatorDependency<double>::RangeToValidatorMap tempranges;
tempranges[std::pair<double,double>(100,200)] = lowTempCheeseValidator;
tempranges[std::pair<double,double>(200,300)] = highTempCheeseValidator;
RCP<RangeValidatorDependency<double> >
cheeseTempDep = RCP<RangeValidatorDependency<double> >(
new RangeValidatorDependency<double>(
rangeValidatorDepList.getEntryRCP("Temperature"),
rangeValidatorDepList.getEntryRCP("Cheese to Fondue"),
tempranges,
defaultCheeseValidator
)
);
depSheet1->addDependency(cheeseTempDep);
TEST_ASSERT(depSheet1->hasDependents(
rangeValidatorDepList.getEntryRCP("Temperature")));
RCP<const DependencySheet::DepSet> rangeValiDepSet =
depSheet1->getDependenciesForParameter(
rangeValidatorDepList.getEntryRCP("Temperature"));
TEST_ASSERT(rangeValiDepSet->size() == 1);
rangeValidatorDepList.set("Temperature",250.0);
cheeseTempDep->evaluate();
TEST_ASSERT(
rangeValidatorDepList.getEntry("Cheese to Fondue").validator()
==
highTempCheeseValidator);
TEST_THROW(
rangeValidatorDepList.validateParameters(rangeValidatorDepList),
Exceptions::InvalidParameterValue);
rangeValidatorDepList.set("Cheese to Fondue", "Provalone");
TEST_NOTHROW(
rangeValidatorDepList.validateParameters(rangeValidatorDepList));
rangeValidatorDepList.set("Temperature", 50.0);
cheeseTempDep->evaluate();
TEST_ASSERT(
rangeValidatorDepList.getEntry("Cheese to Fondue").validator()
==
defaultCheeseValidator
);
}
