00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "unit.hpp"
00022
00023 #include <transports/corba/corba.h>
00024 #include <rtt/InputPort.hpp>
00025 #include <rtt/OutputPort.hpp>
00026 #include <rtt/OperationCaller.hpp>
00027 #include <rtt/TaskContext.hpp>
00028 #include <transports/corba/TaskContextServer.hpp>
00029 #include <transports/corba/TaskContextProxy.hpp>
00030 #include <rtt/Service.hpp>
00031 #include <rtt/transports/corba/DataFlowI.h>
00032 #include <rtt/transports/corba/RemotePorts.hpp>
00033 #include <transports/corba/ServiceC.h>
00034 #include <transports/corba/CorbaLib.hpp>
00035 #include <transports/corba/CorbaConnPolicy.hpp>
00036
00037 #include "operations_fixture.hpp"
00038
00039 using namespace std;
00040 using corba::TaskContextProxy;
00041
00042 class CorbaTest : public OperationsFixture
00043 {
00044 public:
00045 CorbaTest() :
00046 pint1("pint1", "", 3), pdouble1(new Property<double>("pdouble1", "", -3.0)),
00047 aint1(3), adouble1(-3.0), wait(0)
00048 {
00049
00050 mi1 = new InputPort<double> ("mi");
00051 mo1 = new OutputPort<double> ("mo");
00052
00053 mi2 = new InputPort<double> ("mi");
00054 mo2 = new OutputPort<double> ("mo");
00055
00056 tc->ports()->addEventPort(*mi1);
00057 tc->ports()->addPort(*mo1);
00058
00059 t2 = new TaskContext("local");
00060 t2->ports()->addEventPort(*mi2,boost::bind(&CorbaTest::new_data_listener, this, _1));
00061 t2->ports()->addPort(*mo2);
00062
00063 ts2 = ts = 0;
00064 tp2 = tp = 0;
00065
00066
00067 tc->provides()->addProperty(pint1);
00068 storeProperty(*tc->provides()->properties(), "s1.s2", pdouble1 );
00069
00070 tc->addAttribute("aint1", aint1);
00071 tc->addAttribute("adouble1", adouble1);
00072 }
00073 ~CorbaTest()
00074 {
00075 delete tp;
00076 delete ts;
00077 delete tp2;
00078 delete ts2;
00079 delete t2;
00080
00081 delete mi1;
00082 delete mo1;
00083 delete mi2;
00084 delete mo2;
00085 }
00086
00087 TaskContext* t2;
00088 TaskContext* tp;
00089 corba::TaskContextServer* ts;
00090 TaskContext* tp2;
00091 corba::TaskContextServer* ts2;
00092
00093 base::PortInterface* signalled_port;
00094 void new_data_listener(base::PortInterface* port);
00095
00096
00097 InputPort<double>* mi1;
00098 OutputPort<double>* mo1;
00099 InputPort<double>* mi2;
00100 OutputPort<double>* mo2;
00101
00102 Property<int> pint1;
00103 Property<double>* pdouble1;
00104
00105 int aint1;
00106 double adouble1;
00107 int wait;
00108
00109
00110 void testPortDataConnection();
00111 void testPortBufferConnection();
00112 void testPortDisconnected();
00113 };
00114
00115 void CorbaTest::new_data_listener(base::PortInterface* port)
00116 {
00117 signalled_port = port;
00118 }
00119
00120
00121 #define ASSERT_PORT_SIGNALLING(code, read_port) \
00122 signalled_port = 0; wait = 0;\
00123 code; \
00124 while (read_port != signalled_port && wait++ != 5) \
00125 usleep(100000); \
00126 BOOST_CHECK( read_port == signalled_port );
00127
00128 bool wait_for_helper;
00129 #define wait_for( cond, times ) \
00130 wait = 0; \
00131 while( (wait_for_helper = !(cond)) && wait++ != times ) \
00132 usleep(100000); \
00133 if (wait_for_helper) BOOST_CHECK( cond );
00134
00135 #define wait_for_equal( a, b, times ) \
00136 wait = 0; \
00137 while( (wait_for_helper = ((a) != (b))) && wait++ != times ) \
00138 usleep(100000); \
00139 if (wait_for_helper) BOOST_CHECK_EQUAL( a, b );
00140
00141 void CorbaTest::testPortDataConnection()
00142 {
00143
00144
00145 BOOST_CHECK( mo1->connected() );
00146 BOOST_CHECK( mi2->connected() );
00147
00148 double value = 0;
00149
00150
00151 BOOST_CHECK_EQUAL( mi2->read(value), NoData );
00152
00153
00154 ASSERT_PORT_SIGNALLING(mo1->write(1.0), mi2)
00155 BOOST_CHECK( mi2->read(value) );
00156 BOOST_CHECK_EQUAL( 1.0, value );
00157 ASSERT_PORT_SIGNALLING(mo1->write(2.0), mi2);
00158 BOOST_CHECK( mi2->read(value) );
00159 BOOST_CHECK_EQUAL( 2.0, value );
00160 }
00161
00162 void CorbaTest::testPortBufferConnection()
00163 {
00164
00165
00166 BOOST_CHECK( mo1->connected() );
00167 BOOST_CHECK( mi2->connected() );
00168
00169 double value = 0;
00170
00171
00172 BOOST_CHECK_EQUAL( mi2->read(value), NoData );
00173
00174
00175 ASSERT_PORT_SIGNALLING(mo1->write(1.0), mi2);
00176 ASSERT_PORT_SIGNALLING(mo1->write(2.0), mi2);
00177 ASSERT_PORT_SIGNALLING(mo1->write(3.0), mi2);
00178 BOOST_CHECK( mi2->read(value) );
00179 BOOST_CHECK_EQUAL( 1.0, value );
00180 BOOST_CHECK( mi2->read(value) );
00181 BOOST_CHECK_EQUAL( 2.0, value );
00182 BOOST_CHECK( mi2->read(value) );
00183 BOOST_CHECK_EQUAL( 3.0, value );
00184 BOOST_CHECK_EQUAL( mi2->read(value), OldData );
00185 }
00186
00187 void CorbaTest::testPortDisconnected()
00188 {
00189 BOOST_CHECK( !mo1->connected() );
00190 BOOST_CHECK( !mi2->connected() );
00191 }
00192
00193
00194
00195 BOOST_FIXTURE_TEST_SUITE( CorbaTestSuite, CorbaTest )
00196
00197 BOOST_AUTO_TEST_CASE( testAttributes )
00198 {
00199 ts = corba::TaskContextServer::Create( tc, false );
00200 BOOST_CHECK( ts );
00201 tp = corba::TaskContextProxy::Create( ts->server(), true );
00202 BOOST_CHECK( tp );
00203
00204 BOOST_CHECK( tp->provides()->hasAttribute("aint1") );
00205 Attribute<int> proxy_int = tp->provides()->getAttribute("aint1");
00206 BOOST_REQUIRE( proxy_int.ready() );
00207
00208
00209 BOOST_CHECK_EQUAL( proxy_int.get(), 3);
00210
00211 aint1 = 4;
00212 BOOST_CHECK_EQUAL( proxy_int.set(), 4);
00213
00214 proxy_int.set( 5 );
00215 BOOST_CHECK_EQUAL( aint1, 5);
00216
00217 BOOST_CHECK( tp->provides()->hasAttribute("adouble1") );
00218 Attribute<double> proxy_double = tp->provides()->getAttribute("adouble1");
00219 BOOST_REQUIRE( proxy_double.ready() );
00220
00221
00222 BOOST_CHECK_EQUAL( proxy_double.set(), -3.0 );
00223
00224 proxy_double.set( 5.0 );
00225 BOOST_CHECK_EQUAL( adouble1, 5.0 );
00226 BOOST_CHECK_EQUAL( proxy_double.get(), 5.0);
00227 adouble1 = 6.0;
00228
00229 BOOST_CHECK_EQUAL( proxy_double.get(), 6.0);
00230 }
00231
00232 BOOST_AUTO_TEST_CASE( testProperties )
00233 {
00234 ts = corba::TaskContextServer::Create( tc, false );
00235 BOOST_CHECK( ts );
00236 tp = corba::TaskContextProxy::Create( ts->server(), true );
00237 BOOST_CHECK( tp );
00238
00239 BOOST_CHECK( findProperty( *tp->provides()->properties(), "pint1") );
00240 Property<int> proxy_int = findProperty( *tp->provides()->properties(), "pint1");
00241 BOOST_REQUIRE( proxy_int.ready() );
00242
00243 BOOST_CHECK_EQUAL( proxy_int.get(), 3);
00244
00245 pint1 = 4;
00246 BOOST_CHECK_EQUAL( proxy_int.set(), 4);
00247
00248 proxy_int.set( 5 );
00249 BOOST_CHECK_EQUAL( pint1, 5);
00250
00251 BOOST_CHECK( findProperty( *tp->provides()->properties(), "s1.s2.pdouble1") );
00252 Property<double> proxy_d = findProperty( *tp->provides()->properties(), "s1.s2.pdouble1");
00253 BOOST_REQUIRE( proxy_d.ready() );
00254
00255 BOOST_CHECK_EQUAL( proxy_d.set(), -3.0 );
00256
00257 proxy_d.set( 5.0 );
00258 BOOST_CHECK_EQUAL( pdouble1->get(), 5.0 );
00259 BOOST_CHECK_EQUAL( proxy_d.get(), 5.0);
00260 pdouble1->set( 6.0 );
00261
00262 BOOST_CHECK_EQUAL( proxy_d.get(), 6.0);
00263 }
00264
00265 BOOST_AUTO_TEST_CASE( testOperationCallerC_Call )
00266 {
00267
00268 ts = corba::TaskContextServer::Create( tc, false );
00269 BOOST_CHECK( ts );
00270 tp = corba::TaskContextProxy::Create( ts->server(), true );
00271 BOOST_CHECK( tp );
00272
00273
00274 internal::OperationCallerC mc;
00275 double r = 0.0;
00276 mc = tp->provides("methods")->create("vm0", tc->engine() );
00277 BOOST_CHECK( mc.call() );
00278 BOOST_CHECK( r == 0.0 );
00279
00280 mc = tp->provides("methods")->create("m0", tc->engine() ).ret( r );
00281 BOOST_CHECK( mc.call() );
00282 BOOST_CHECK( r == -1.0 );
00283
00284 mc = tp->provides("methods")->create("m2", tc->engine() ).argC(1).argC(2.0).ret( r );
00285 BOOST_CHECK( mc.call() );
00286 BOOST_CHECK( r == -3.0 );
00287
00288 mc = tp->provides("methods")->create("m3", tc->engine() ).ret( r ).argC(1).argC(2.0).argC(true);
00289 BOOST_CHECK( mc.call() );
00290 BOOST_CHECK( r == -4.0 );
00291
00292 mc = tp->provides("methods")->create("m0except", tc->engine() );
00293 BOOST_CHECK_THROW( mc.call(), std::runtime_error );
00294 BOOST_REQUIRE( tc->inException() );
00295 }
00296
00297 BOOST_AUTO_TEST_CASE( testOperationCallerC_Send )
00298 {
00299
00300 ts = corba::TaskContextServer::Create( tc, false );
00301 BOOST_CHECK( ts );
00302 tp = corba::TaskContextProxy::Create( ts->server(), true );
00303 BOOST_CHECK( tp );
00304
00305 OperationCallerC mc;
00306 SendHandleC shc;
00307 double r = 0.0;
00308 double cr = 0.0;
00309 mc = tp->provides("methods")->create("m0", caller->engine()).ret( r );
00310 BOOST_CHECK_NO_THROW( mc.check() );
00311 shc = mc.send();
00312 shc.arg(cr);
00313 BOOST_CHECK( shc.ready() );
00314 BOOST_CHECK_NO_THROW( shc.check() );
00315
00316 BOOST_CHECK_EQUAL( shc.collect(), SendSuccess);
00317 BOOST_CHECK_EQUAL( r, 0.0 );
00318 BOOST_CHECK_EQUAL( cr, -1.0 );
00319
00320 mc = tp->provides("methods")->create("m2", caller->engine()).argC(1).argC(2.0).ret( r );
00321 BOOST_CHECK_NO_THROW( mc.check() );
00322 shc = mc.send();
00323 shc.arg(cr);
00324 BOOST_CHECK( shc.ready() );
00325 BOOST_CHECK_NO_THROW( shc.check() );
00326
00327 BOOST_CHECK_EQUAL( shc.collect(), SendSuccess);
00328 BOOST_CHECK_EQUAL( r, 0.0 );
00329 BOOST_CHECK_EQUAL( cr, -3.0 );
00330
00331 mc = tp->provides("methods")->create("m3", caller->engine()).ret( r ).argC(1).argC(2.0).argC(true);
00332 BOOST_CHECK_NO_THROW( mc.check() );
00333 shc = mc.send();
00334 shc.arg(cr);
00335 BOOST_CHECK( shc.ready() );
00336 BOOST_CHECK_NO_THROW( shc.check() );
00337
00338 BOOST_CHECK_EQUAL( shc.collect(), SendSuccess);
00339 BOOST_CHECK_EQUAL( r, 0.0 );
00340 BOOST_CHECK_EQUAL( cr, -4.0 );
00341
00342 mc = tp->provides("methods")->create("m4", caller->engine()).ret( r ).argC(1).argC(2.0).argC(true).argC(string("hello"));
00343 BOOST_CHECK_NO_THROW( mc.check() );
00344 shc = mc.send();
00345 shc.arg(cr);
00346 BOOST_CHECK( shc.ready() );
00347 BOOST_CHECK_NO_THROW( shc.check() );
00348
00349 BOOST_CHECK_EQUAL( shc.collect(), SendSuccess);
00350 BOOST_CHECK_EQUAL( r, 0.0 );
00351 BOOST_CHECK_EQUAL( cr, -5.0 );
00352
00353
00354 mc = tp->provides("methods")->create("m0except", caller->engine());
00355 BOOST_CHECK_NO_THROW( mc.check() );
00356 shc = mc.send();
00357 BOOST_CHECK( shc.ready() );
00358 BOOST_CHECK_NO_THROW( shc.check() );
00359
00360 BOOST_CHECK_THROW( shc.collect(), std::runtime_error);
00361 BOOST_REQUIRE( tc->inException() );
00362 }
00363
00364 BOOST_AUTO_TEST_CASE( testRemoteOperationCallerCall )
00365 {
00366
00367 ts = corba::TaskContextServer::Create( tc, false );
00368 tp = corba::TaskContextProxy::Create( ts->server(), true );
00369
00370
00371
00372 RTT::OperationCaller<double(void)> m0 = tp->provides("methods")->getOperation("m0");
00373 RTT::OperationCaller<double(int)> m1 = tp->provides("methods")->getOperation("m1");
00374 RTT::OperationCaller<double(int,double)> m2 = tp->provides("methods")->getOperation("m2");
00375 RTT::OperationCaller<double(int,double,bool)> m3 = tp->provides("methods")->getOperation("m3");
00376 RTT::OperationCaller<double(int,double,bool,std::string)> m4 = tp->provides("methods")->getOperation("m4");
00377 RTT::OperationCaller<void(void)> m0e = tp->provides("methods")->getOperation("m0except");
00378
00379 BOOST_CHECK_EQUAL( -1.0, m0() );
00380 BOOST_CHECK_EQUAL( -2.0, m1(1) );
00381 BOOST_CHECK_EQUAL( -3.0, m2(1, 2.0) );
00382 BOOST_CHECK_EQUAL( -4.0, m3(1, 2.0, true) );
00383 BOOST_CHECK_EQUAL( -5.0, m4(1, 2.0, true,"hello") );
00384 BOOST_CHECK_THROW( m0e(), std::runtime_error );
00385 BOOST_REQUIRE( tc->inException() );
00386 }
00387
00388 BOOST_AUTO_TEST_CASE( testAnyOperationCaller )
00389 {
00390 double d;
00391
00392 ts = corba::TaskContextServer::Create( tc, false );
00393 tp = corba::TaskContextProxy::Create( ts->server() , true);
00394
00395
00396 corba::CService_var co = ts->server()->getProvider("methods");
00397 BOOST_CHECK( co.in() );
00398
00399 corba::CAnyArguments_var any_args = new corba::CAnyArguments(0);
00400 CORBA::Any_var vm0 = co->callOperation("vm0", any_args.inout() );
00401
00402
00403 CORBA::Any_var m0 = co->callOperation("m0", any_args.inout());
00404 BOOST_CHECK( m0 >>= d );
00405 BOOST_CHECK_EQUAL(d, -1.0 );
00406
00407 any_args = new corba::CAnyArguments(1);
00408 any_args->length(1);
00409 unsigned int index = 0;
00410 any_args[index] <<= (CORBA::Long) 1;
00411 CORBA::Any_var m1;
00412 BOOST_CHECK_NO_THROW( m1 = co->callOperation("m1", any_args.inout()));
00413 BOOST_CHECK( m1 >>= d );
00414 BOOST_CHECK_EQUAL(d, -2.0 );
00415
00416 any_args = new corba::CAnyArguments(2);
00417 any_args->length(2);
00418 index = 0;
00419 any_args[index] <<= (CORBA::Long) 1;
00420 ++index;
00421 any_args[index] <<= (CORBA::Double) 2.0;
00422 CORBA::Any_var m2;
00423 BOOST_CHECK_NO_THROW( m2 = co->callOperation("m2", any_args.inout()));
00424 BOOST_CHECK( m2 >>= d );
00425 BOOST_CHECK_EQUAL(d, -3.0 );
00426
00427 any_args = new corba::CAnyArguments(3);
00428 any_args->length(3);
00429 index = 0;
00430 any_args[index] <<= (CORBA::Long) 1;
00431 ++index;
00432 any_args[index] <<= (CORBA::Double) 2.0;
00433 ++index;
00434 any_args[index] <<= CORBA::Any::from_boolean( true );
00435 CORBA::Any_var m3;
00436 BOOST_CHECK_NO_THROW( m3= co->callOperation("m3", any_args.inout()) );
00437 BOOST_CHECK( m3 >>= d );
00438 BOOST_CHECK_EQUAL(d, -4.0 );
00439
00440 any_args = new corba::CAnyArguments(4);
00441 any_args->length(4);
00442 index = 0;
00443 any_args[index] <<= (CORBA::Long) 1;
00444 ++index;
00445 any_args[index] <<= (CORBA::Double) 2.0;
00446 ++index;
00447 any_args[index] <<= CORBA::Any::from_boolean( true );
00448 ++index;
00449 any_args[index] <<= "hello";
00450 CORBA::Any_var m4;
00451 BOOST_CHECK_NO_THROW ( m4 = co->callOperation("m4", any_args.inout()) );
00452 BOOST_CHECK( m4 >>= d );
00453 BOOST_CHECK_EQUAL(d, -5.0 );
00454
00455 any_args = new corba::CAnyArguments(0);
00456 BOOST_CHECK_THROW(co->callOperation("m0except", any_args.inout() ), ::RTT::corba::CCallError);
00457 BOOST_REQUIRE( tc->inException() );
00458 }
00459
00460 BOOST_AUTO_TEST_CASE(testDataFlowInterface)
00461 {
00462 ts = corba::TaskContextServer::Create( tc, false );
00463
00464 corba::CDataFlowInterface_var ports = ts->server()->ports();
00465
00466 corba::CDataFlowInterface::CPortNames_var names =
00467 ports->getPorts();
00468
00469 BOOST_CHECK_EQUAL(CORBA::ULong(2), names->length());
00470 BOOST_CHECK_EQUAL(string("mi"), string(names[CORBA::ULong(0)]));
00471 BOOST_CHECK_EQUAL(string("mo"), string(names[CORBA::ULong(1)]));
00472
00473
00474 BOOST_CHECK_EQUAL(RTT::corba::COutput,
00475 ports->getPortType("mo"));
00476 BOOST_CHECK_EQUAL(RTT::corba::CInput,
00477 ports->getPortType("mi"));
00478
00479
00480 CORBA::String_var cstr = ports->getDataType("mo");
00481 BOOST_CHECK_EQUAL(string("double"),
00482 string(cstr.in()));
00483 }
00484
00485 BOOST_AUTO_TEST_CASE( testPortConnections )
00486 {
00487
00488 ts = corba::TaskContextServer::Create( tc, false );
00489 ts2 = corba::TaskContextServer::Create( t2, false );
00490
00491
00492 RTT::corba::CConnPolicy policy = toCORBA(ConnPolicy::data());
00493 policy.init = false;
00494 policy.transport = ORO_CORBA_PROTOCOL_ID;
00495
00496 corba::CDataFlowInterface_var ports = ts->server()->ports();
00497 corba::CDataFlowInterface_var ports2 = ts2->server()->ports();
00498
00499
00500 BOOST_CHECK_THROW( ports->createConnection("mo", ports2, "does_not_exist", policy), CNoSuchPortException );
00501 BOOST_CHECK_THROW( ports->createConnection("does_not_exist", ports2, "mi", policy), CNoSuchPortException );
00502 BOOST_CHECK_THROW( ports->createConnection("does_not_exist", ports2, "does_not_exist", policy), CNoSuchPortException );
00503 BOOST_CHECK_THROW( ports->createConnection("mo", ports2, "mo", policy), CNoSuchPortException );
00504 BOOST_CHECK_THROW( ports->createConnection("mi", ports2, "mi", policy), CNoSuchPortException );
00505 BOOST_CHECK_THROW( ports->createConnection("mi", ports2, "mo", policy), CNoSuchPortException );
00506
00507
00508 BOOST_CHECK( t2->start() );
00509
00510
00511
00512
00513 policy.type = RTT::corba::CData;
00514 policy.pull = false;
00515 BOOST_CHECK( ports->createConnection("mo", ports2, "mi", policy) );
00516 testPortDataConnection();
00517 ports->disconnectPort("mo");
00518 testPortDisconnected();
00519
00520 policy.type = RTT::corba::CData;
00521 policy.pull = true;
00522 BOOST_CHECK( ports->createConnection("mo", ports2, "mi", policy) );
00523 testPortDataConnection();
00524 ports2->disconnectPort("mi");
00525 testPortDisconnected();
00526
00527 policy.type = RTT::corba::CBuffer;
00528 policy.pull = false;
00529 policy.size = 3;
00530 BOOST_CHECK( ports->createConnection("mo", ports2, "mi", policy) );
00531 testPortBufferConnection();
00532 ports->disconnectPort("mo");
00533 testPortDisconnected();
00534
00535 policy.type = RTT::corba::CBuffer;
00536 policy.pull = true;
00537 BOOST_CHECK( ports->createConnection("mo", ports2, "mi", policy) );
00538 testPortBufferConnection();
00539
00540
00541 mo1->createConnection(*mi1);
00542
00543 ports->removeConnection("mo", ports2, "mi");
00544
00545 BOOST_CHECK(mo1->connected());
00546 BOOST_CHECK(mi1->connected());
00547 BOOST_CHECK(!mi2->connected());
00548 }
00549
00550 BOOST_AUTO_TEST_CASE( testPortProxying )
00551 {
00552 ts = corba::TaskContextServer::Create( tc, false );
00553 tp = corba::TaskContextProxy::Create( ts->server(), true );
00554 ts2 = corba::TaskContextServer::Create( t2, false );
00555 tp2 = corba::TaskContextProxy::Create( ts2->server(), true );
00556
00557 base::PortInterface* untyped_port;
00558
00559 untyped_port = tp->ports()->getPort("mi");
00560 BOOST_CHECK(untyped_port);
00561 base::InputPortInterface* read_port = dynamic_cast<base::InputPortInterface*>(tp->ports()->getPort("mi"));
00562 BOOST_CHECK(read_port);
00563
00564 untyped_port = tp->ports()->getPort("mi");
00565 BOOST_CHECK(untyped_port);
00566 base::OutputPortInterface* write_port = dynamic_cast<base::OutputPortInterface*>(tp2->ports()->getPort("mo"));
00567 BOOST_CHECK(write_port);
00568
00569
00570
00571 BOOST_CHECK(dynamic_cast<corba::RemoteInputPort*>(read_port));
00572 BOOST_CHECK(dynamic_cast<corba::RemoteOutputPort*>(write_port));
00573
00574 BOOST_CHECK(!read_port->connected());
00575 BOOST_CHECK(read_port->getTypeInfo() == mi1->getTypeInfo());
00576 BOOST_CHECK(!write_port->connected());
00577 BOOST_CHECK(write_port->getTypeInfo() == mo2->getTypeInfo());
00578
00579 mo2->createConnection(*read_port);
00580 BOOST_CHECK(read_port->connected());
00581 BOOST_CHECK(write_port->connected());
00582 read_port->disconnect();
00583 BOOST_CHECK(!read_port->connected());
00584 BOOST_CHECK(!write_port->connected());
00585
00586 mo2->createConnection(*read_port);
00587 BOOST_CHECK(read_port->connected());
00588 BOOST_CHECK(write_port->connected());
00589 write_port->disconnect();
00590 BOOST_CHECK(!read_port->connected());
00591 BOOST_CHECK(!write_port->connected());
00592
00593
00594 auto_ptr<base::InputPortInterface> read_clone(dynamic_cast<base::InputPortInterface*>(read_port->clone()));
00595 BOOST_CHECK(mo2->createConnection(*read_clone));
00596 BOOST_CHECK(read_clone->connected());
00597 BOOST_CHECK(!read_port->connected());
00598 mo2->disconnect();
00599 }
00600
00601 BOOST_AUTO_TEST_CASE( testDataHalfs )
00602 {
00603 double result;
00604
00605 ts = corba::TaskContextServer::Create( tc, false );
00606
00607
00608 RTT::corba::CConnPolicy policy = toCORBA(ConnPolicy::data());
00609 policy.init = false;
00610 policy.transport = ORO_CORBA_PROTOCOL_ID;
00611
00612 corba::CDataFlowInterface_var ports = ts->server()->ports();
00613 BOOST_REQUIRE( ports.in() );
00614
00615
00616 policy.pull = false;
00617 CChannelElement_var cce = ports->buildChannelInput("mo", policy);
00618 CORBA::Any_var sample = new CORBA::Any();
00619 BOOST_REQUIRE( cce.in() );
00620
00621 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), CNoData );
00622
00623 mo1->write( 3.33 );
00624 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), CNewData );
00625 sample >>= result;
00626 BOOST_CHECK_EQUAL( result, 3.33);
00627
00628
00629 sample <<= 0.0;
00630 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), COldData );
00631 sample >>= result;
00632 BOOST_CHECK_EQUAL( result, 3.33);
00633
00634 cce->disconnect();
00635
00636
00637 cce = ports->buildChannelOutput("mi", policy);
00638 ports->channelReady("mi", cce, policy);
00639 sample = new CORBA::Any();
00640 BOOST_REQUIRE( cce.in() );
00641
00642
00643 result = 0.0;
00644 sample <<= 4.44;
00645 cce->write( sample.in() );
00646 BOOST_CHECK_EQUAL( mi1->read( result ), NewData );
00647 BOOST_CHECK_EQUAL( result, 4.44 );
00648
00649
00650 result = 0.0;
00651 BOOST_CHECK_EQUAL( mi1->read( result ), OldData );
00652 BOOST_CHECK_EQUAL( result, 4.44);
00653 }
00654
00655 BOOST_AUTO_TEST_CASE( testBufferHalfs )
00656 {
00657 double result;
00658
00659 ts = corba::TaskContextServer::Create( tc, false );
00660
00661
00662 RTT::corba::CConnPolicy policy = toCORBA(ConnPolicy::buffer(10));
00663 policy.init = false;
00664 policy.transport = ORO_CORBA_PROTOCOL_ID;
00665
00666 corba::CDataFlowInterface_var ports = ts->server()->ports();
00667 BOOST_REQUIRE( ports.in() );
00668
00669
00670 policy.pull = false;
00671 CChannelElement_var cce = ports->buildChannelInput("mo", policy);
00672 CORBA::Any_var sample = new CORBA::Any();
00673 BOOST_REQUIRE( cce.in() );
00674
00675 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), CNoData );
00676
00677 mo1->write( 6.33 );
00678 mo1->write( 3.33 );
00679 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), CNewData );
00680 sample >>= result;
00681 BOOST_CHECK_EQUAL( result, 6.33);
00682 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), CNewData );
00683 sample >>= result;
00684 BOOST_CHECK_EQUAL( result, 3.33);
00685
00686
00687 sample <<= 0.0;
00688 BOOST_CHECK_EQUAL( cce->read( sample.out(), true ), COldData );
00689 sample >>= result;
00690 BOOST_CHECK_EQUAL( result, 3.33);
00691
00692 cce->disconnect();
00693
00694
00695 cce = ports->buildChannelOutput("mi", policy);
00696 ports->channelReady("mi", cce, policy);
00697 sample = new CORBA::Any();
00698 BOOST_REQUIRE( cce.in() );
00699
00700
00701 result = 0.0;
00702 sample <<= 6.44;
00703 cce->write( sample.in() );
00704 sample <<= 4.44;
00705 cce->write( sample.in() );
00706 BOOST_CHECK_EQUAL( mi1->read( result ), NewData );
00707 BOOST_CHECK_EQUAL( result, 6.44 );
00708 BOOST_CHECK_EQUAL( mi1->read( result ), NewData );
00709 BOOST_CHECK_EQUAL( result, 4.44 );
00710
00711
00712 result = 0.0;
00713 BOOST_CHECK_EQUAL( mi1->read( result ), OldData );
00714 BOOST_CHECK_EQUAL( result, 4.44);
00715 }
00716
00717 BOOST_AUTO_TEST_SUITE_END()
00718