00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include <typeinfo>
00020 #include <marsh/PropertyBagIntrospector.hpp>
00021 #include <internal/DataSourceTypeInfo.hpp>
00022 #include <types/PropertyDecomposition.hpp>
00023 #include <Property.hpp>
00024 #include <PropertyBag.hpp>
00025
00026 #include "unit.hpp"
00027
00028 class PropertyTest
00029 {
00030 public:
00031 PropertyBag bag1;
00032 PropertyBag bag2;
00033 PropertyBase* pb;
00034 Property<int>* pi1;
00035 Property<int>* pi2;
00036 Property<int>* pi1ref;
00037 Property<int>* pi2ref;
00038 int intref;
00039
00040 PropertyBag bag;
00041 Property<float> pf;
00042 Property<double> pd;
00043 Property<std::string> ps;
00044 Property<char> pc;
00045 Property<char> pc1;
00046 Property<char> pc2;
00047 Property<char> pc1ref;
00048 Property<char> pc2ref;
00049
00050 Property<PropertyBag> subbag1;
00051 Property<PropertyBag> subbag2;
00052
00053 PropertyTest()
00054 : pf("pf","pfd", -1.0),pd("pd","pdd", +1.0),
00055 ps("ps","psd", "std::string"),
00056 pc("pc","pcd", 'c'),
00057 pc1("pc1","pcd1", 'a'),
00058 pc2("pc2","pcd1", 'b'),
00059 subbag1("s1", "s1d"),subbag2("s2", "s2d")
00060 {
00061 intref = 99;
00062 pi1 = new Property<int>("pi1","pi1d", 0 );
00063 pi2 = new Property<int>("pi2","pi2d", 0 );
00064 pi1ref = dynamic_cast< Property<int>* >( pi1->clone() );
00065 pi2ref = dynamic_cast< Property<int>* >( pi2->clone() );
00066
00067 pc1ref = pc1;
00068 pc2ref = pc2;
00069
00070 bag.add( pi1 );
00071 bag.add( pi2 );
00072 bag.add( &subbag1 );
00073 subbag1.set().add( &subbag2 );
00074 subbag1.set().add( &pf );
00075 subbag1.set().add( &pd );
00076
00077 subbag2.set().add( &ps );
00078 subbag2.set().add( &pc );
00079
00080 }
00081 ~PropertyTest()
00082 {
00083 delete pi1;
00084 delete pi2;
00085 delete pi1ref;
00086 delete pi2ref;
00087 }
00088 };
00089
00090 bool operator==(const std::vector<double>& a, const std::vector<double>& b)
00091 {
00092 if ( a.size() != b.size() ) {
00093 log(Error) << "Wrong vector sizes : " << a.size() <<" "<< b.size()<<endlog();
00094 return false;
00095 }
00096 for(unsigned int i =0; i != a.size(); ++i)
00097 {
00098 if (a[i] != b[i]) {
00099 log(Error) << "Wrong vector element: "<<a[i]<<" != "<<b[i]<<" i:" << i<<endlog();
00100 return false;
00101 }
00102 }
00103 return true;
00104 }
00105
00106
00107 BOOST_FIXTURE_TEST_SUITE( PropertyTestSuite, PropertyTest )
00108
00109 BOOST_AUTO_TEST_CASE( testCopyUpdate )
00110 {
00111 *pi1 = intref;
00112 *pi2 = 0;
00113
00114
00115 pi1->update( *pi2 );
00116 BOOST_REQUIRE_EQUAL( pi2->get(), pi1->get() );
00117 BOOST_REQUIRE_EQUAL( pi1ref->getName(), pi1->getName() );
00118 BOOST_REQUIRE_EQUAL( pi1ref->getDescription(), pi1->getDescription() );
00119 *pi2 = 0;
00120
00121
00122 BOOST_CHECK( pi1->update( pi2 ) );
00123 BOOST_REQUIRE_EQUAL( pi2->get(), pi1->get() );
00124 BOOST_REQUIRE_EQUAL( pi1ref->getName(), pi1->getName() );
00125 BOOST_REQUIRE_EQUAL( pi1ref->getDescription(), pi1->getDescription() );
00126 *pi2 = 0;
00127
00128
00129 pi1->copy( *pi2 );
00130 BOOST_REQUIRE_EQUAL( pi2->get(), pi1->get() );
00131 BOOST_REQUIRE_EQUAL( pi2ref->getName(), pi1->getName() );
00132 BOOST_REQUIRE_EQUAL( pi2ref->getDescription(), pi1->getDescription() );
00133 pi1->copy( *pi1ref );
00134
00135
00136 BOOST_CHECK( pi1->copy( pi2 ) );
00137 BOOST_REQUIRE_EQUAL( pi2->get(), pi1->get() );
00138 BOOST_REQUIRE_EQUAL( pi2ref->getName(), pi1->getName() );
00139 BOOST_REQUIRE_EQUAL( pi2ref->getDescription(), pi1->getDescription() );
00140 pi1->copy( pi1ref );
00141 }
00142
00143 BOOST_AUTO_TEST_CASE( testCopyUpdateChar )
00144 {
00145 pc2 = 'H';
00146 PropertyBase* pcb2 = &pc2;
00147
00148
00149 pc1.update( pc2 );
00150 BOOST_REQUIRE_EQUAL( pc2.get(), pc1.get() );
00151 BOOST_REQUIRE_EQUAL( pc1ref.getName(), pc1.getName() );
00152 BOOST_REQUIRE_EQUAL( pc1ref.getDescription(), pc1.getDescription() );
00153 pc2 = 'e';
00154
00155
00156 BOOST_CHECK( pc1.update( pcb2 ) );
00157 BOOST_REQUIRE_EQUAL( pc2.get(), pc1.get() );
00158 BOOST_REQUIRE_EQUAL( pc1ref.getName(), pc1.getName() );
00159 BOOST_REQUIRE_EQUAL( pc1ref.getDescription(), pc1.getDescription() );
00160 pc2 = 'l';
00161
00162
00163 pc1.copy( pc2 );
00164 BOOST_REQUIRE_EQUAL( pc2.get(), pc1.get() );
00165 BOOST_REQUIRE_EQUAL( pc2ref.getName(), pc1.getName() );
00166 BOOST_REQUIRE_EQUAL( pc2ref.getDescription(), pc1.getDescription() );
00167 pc1.copy( pc1ref );
00168
00169
00170 BOOST_CHECK( pc1.copy( pcb2 ) );
00171 BOOST_REQUIRE_EQUAL( pc2.get(), pc1.get() );
00172 BOOST_REQUIRE_EQUAL( pc2ref.getName(), pc1.getName() );
00173 BOOST_REQUIRE_EQUAL( pc2ref.getDescription(), pc1.getDescription() );
00174 pc1.copy( pc1ref );
00175 }
00176
00177 BOOST_AUTO_TEST_CASE( testUpdateCharClone )
00178 {
00179 PropertyBag target;
00180
00181 PropertyBase* temp = pc1.create();
00182
00183 BOOST_CHECK( temp->update( &pc1 ) );
00184
00185 target.add( temp );
00186 }
00187
00188 BOOST_AUTO_TEST_CASE( testfindProperty )
00189 {
00190
00191 BOOST_CHECK( bag.find( "pf" ) == 0 );
00192 BOOST_CHECK( bag.find( "s1" ) == &subbag1 );
00193 BOOST_CHECK( bag.find( "pi1" ) == pi1 );
00194
00195
00196 BOOST_CHECK( findProperty( bag, "/pf", "/" ) == 0 );
00197 BOOST_CHECK( findProperty( bag, ".pi1" ) == pi1 );
00198 BOOST_CHECK( findProperty( bag, "s1" ) == &subbag1 );
00199 BOOST_CHECK( findProperty( bag, "pi1" ) == pi1 );
00200 BOOST_CHECK( findProperty( bag, "/s1/s2", "/" ) == &subbag2 );
00201 BOOST_CHECK( findProperty( bag, "/s1/s2/ps", "/" ) == &ps );
00202 BOOST_CHECK( findProperty( bag, "s1.s2.pc" ) == &pc );
00203
00204 }
00205
00206
00207 BOOST_AUTO_TEST_CASE( testlistProperties )
00208 {
00209 vector<string> result = listProperties( bag );
00210 BOOST_CHECK_EQUAL( result.size(), 8);
00211
00212
00213 BOOST_CHECK_EQUAL( result[0], string("pi1"));
00214 BOOST_CHECK_EQUAL( result[1], string("pi2"));
00215 BOOST_CHECK_EQUAL( result[2], string("s1"));
00216 BOOST_CHECK_EQUAL( result[3], string("s1.s2"));
00217 BOOST_CHECK_EQUAL( result[4], string("s1.s2.ps"));
00218 BOOST_CHECK_EQUAL( result[5], string("s1.s2.pc"));
00219 BOOST_CHECK_EQUAL( result[6], string("s1.pf"));
00220 BOOST_CHECK_EQUAL( result[7], string("s1.pd"));
00221 }
00222
00223
00224 BOOST_AUTO_TEST_CASE( teststoreProperty )
00225 {
00226 Property<int>* int1 = new Property<int>("int1","",3);
00227 Property<int>* int2 = new Property<int>("int2","",6);
00228 Property<int>* int3 = new Property<int>("int3","",9);
00229 BOOST_CHECK( storeProperty(bag, "pp1", int1 ));
00230 BOOST_CHECK_EQUAL( findProperty(bag, "pp1.int1"), int1 );
00231
00232 BOOST_CHECK( storeProperty(bag, "pp1.pp2", int2) );
00233 BOOST_CHECK_EQUAL( findProperty(bag, "pp1.pp2.int2"), int2 );
00234
00235 BOOST_CHECK( removeProperty( bag, "pp1.pp2.int2") );
00236 int2 = new Property<int>("int2","",6);
00237
00238
00239 BOOST_CHECK( storeProperty(bag, "##pp1###pp3##", int2, "#") );
00240 BOOST_CHECK_EQUAL( findProperty(bag, "pp1#pp3#int2", "#"), int2 );
00241
00242
00243 BOOST_CHECK( storeProperty(bag, "", int3) );
00244 BOOST_CHECK( findProperty(bag, "int3") );
00245 BOOST_CHECK_EQUAL( bag.find("int3"), int3 );
00246 BOOST_CHECK( bag.ownsProperty( int3 ) );
00247
00248 bag.removeProperty( int3 );
00249 int3 = new Property<int>("int3","",9);
00250
00251
00252 BOOST_CHECK( storeProperty(bag, "#", int3,"#") );
00253 BOOST_CHECK( findProperty(bag, "int3") );
00254 BOOST_CHECK_EQUAL( bag.find("int3"), int3 );
00255 BOOST_CHECK( bag.ownsProperty( int3 ) );
00256 }
00257
00258
00259 BOOST_AUTO_TEST_CASE( testremoveProperty )
00260 {
00261
00262 BOOST_CHECK( removeProperty( bag, "qwerty" ) == false );
00263 BOOST_CHECK( removeProperty( bag, "." ) == false );
00264
00265
00266 BOOST_CHECK( removeProperty( bag, "pi1" ) );
00267 BOOST_CHECK( findProperty( bag, "pi1" ) == 0 );
00268
00269
00270 BOOST_CHECK( removeProperty( bag, "s1.s2.pc" ) );
00271 BOOST_CHECK( findProperty( bag, "s1.s2.pc" ) == 0 );
00272
00273
00274 BOOST_CHECK( removeProperty( bag, "s1.s2" ) );
00275 BOOST_CHECK( findProperty( bag, "s1.s2" ) == 0 );
00276 }
00277
00278 BOOST_AUTO_TEST_CASE( testRepository )
00279 {
00283 BOOST_MESSAGE("----- Testing testRep");
00284 std::vector<string> names = TypeInfoRepository::Instance()->getTypes();
00285 for (std::vector<string>::iterator it = names.begin(); it != names.end(); ++it) {
00286 BOOST_MESSAGE("----------- loop names: " << *it);
00287 PropertyBase* target;
00288 Property<PropertyBag> bag("Result","D");
00289 BOOST_REQUIRE( TypeInfoRepository::Instance()->type( *it ) );
00290 target = TypeInfoRepository::Instance()->type( *it )->buildProperty("Result", "D");
00291 if ( target && typeDecomposition( target->getDataSource(), bag.value() ) )
00292 BOOST_CHECK_MESSAGE( target->getTypeInfo()->composeType( bag.getDataSource() , target->getDataSource() ), "Failed composition for type "+target->getTypeInfo()->getTypeName() );
00293 deletePropertyBag( bag.value() );
00294 delete target;
00295 }
00296
00297 }
00298
00299 BOOST_AUTO_TEST_CASE( testComposition )
00300 {
00304 std::vector<double> init(33, 1.0);
00305 Property<std::vector<double> > pvd("pvd","pvd desc", init);
00306
00307
00308
00309 Property<std::vector<double> > pvd2("pvd 2","pvd desc 2");
00310
00311 BOOST_CHECK( pvd.get() == init );
00312 BOOST_CHECK( pvd.set() == init );
00313
00314 BOOST_REQUIRE( pvd.getTypeInfo() );
00315 BOOST_CHECK( pvd.getTypeInfo() != RTT::detail::DataSourceTypeInfo<RTT::detail::UnknownType>::getTypeInfo() );
00316
00317 Property<PropertyBag> bag("Result","Rd");
00318
00319 BOOST_CHECK( typeDecomposition( pvd.getDataSource(), bag.value() ) );
00320 BOOST_CHECK( pvd.getTypeInfo()->composeType( bag.getDataSource(), pvd2.getDataSource() ) );
00321 BOOST_CHECK( pvd == pvd2 );
00322 pvd2.value().clear();
00323 deletePropertyBag( bag.value() );
00324 }
00325
00327 BOOST_AUTO_TEST_CASE( testNewDecomposition )
00328 {
00332 std::vector<double> init(33, 1.0);
00333
00334 Property<std::vector<double> > pvd("pvd","pvd desc", init);
00335
00336 BOOST_CHECK( pvd.get() == init );
00337 BOOST_CHECK( pvd.set() == init );
00338
00339 BOOST_REQUIRE( pvd.getTypeInfo() );
00340 BOOST_CHECK( pvd.getTypeInfo() != RTT::detail::DataSourceTypeInfo<RTT::detail::UnknownType>::getTypeInfo() );
00341
00342 Property<PropertyBag> bag("Result","Rd");
00343
00344 BOOST_CHECK( propertyDecomposition( &pvd, bag.value() ) );
00345
00346 Property<double> pvalue = bag.value().getItem(3);
00347 BOOST_REQUIRE( pvalue.ready() );
00348 pvalue.set( 42 );
00349
00350 BOOST_CHECK( pvd.rvalue()[3] == 42 );
00351
00352 deletePropertyBag( bag.value() );
00353 }
00354
00355
00356 BOOST_AUTO_TEST_CASE( testInit )
00357 {
00358
00359
00360 Property<unsigned int> pui("PUI","", 0 );
00361 Property<int> pi("PI","", 0 );
00362 Property<bool> pb("PB","", false );
00363
00364
00365 PropertyBase* pbase = 0;
00366 Property<int> p2 = pbase;
00367 BOOST_CHECK( !p2.ready() );
00368 Property<int> p3;
00369 BOOST_CHECK( !p3.ready() );
00370
00371 p3 = pbase;
00372 BOOST_CHECK( !p3.ready() );
00373
00374 p2 = p3;
00375 BOOST_CHECK( !p2.ready() );
00376
00377 p2 = pi;
00378 BOOST_CHECK( p2.ready() );
00379
00380 BOOST_CHECK(true);
00381 }
00382
00383
00384 BOOST_AUTO_TEST_CASE( testUpdate )
00385 {
00386 PropertyBag source;
00387 PropertyBag target;
00388
00389 Property<PropertyBag> b1("b1","");
00390 Property<PropertyBag> b2("b2","");
00391 Property<int> p1("p1","",-1);
00392
00393 Property<PropertyBag> b1c("b1","");
00394 Property<PropertyBag> b2c("b2","");
00395 Property<int> p1c("p1","",0);
00396
00397
00398 source.addProperty( b1 );
00399 b1.value().addProperty( b2 );
00400 b2.value().addProperty( p1 );
00401
00402
00403
00404 target.addProperty( b1c );
00405 b1c.value().addProperty( b2c );
00406 b2c.value().addProperty( p1c );
00407
00408 BOOST_CHECK( p1.get() != p1c.get() );
00409
00410 BOOST_CHECK( updateProperty(target, source, "b1/b2/p1", "/") );
00411
00412 BOOST_CHECK( p1.get() == -1 );
00413 BOOST_CHECK( p1c.get() == -1 );
00414
00415
00416 target.removeProperty(&b1);
00417 BOOST_CHECK( updateProperty(target, source, "b1/b2/p1", "/") );
00418
00419 Property<PropertyBag>* bag = target.getPropertyType<PropertyBag>("b1");
00420 BOOST_CHECK( bag );
00421 BOOST_CHECK( bag->getName() == "b1" );
00422 bag = bag->get().getPropertyType<PropertyBag>("b2");
00423 BOOST_CHECK( bag );
00424 BOOST_CHECK( bag->getName() == "b2" );
00425
00426 Property<int>* res = bag->get().getPropertyType<int>("p1");
00427 BOOST_CHECK( res );
00428 BOOST_CHECK( res->getName() == "p1" );
00429 BOOST_CHECK( res->get() == -1 );
00430
00431 }
00432
00433 BOOST_AUTO_TEST_SUITE_END()