// 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 ); }