src/runtime/Test/runtimeTest.cxx

   1 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
   2
   3 #include "Bloc.hxx"
   4 #include "ElementaryNode.hxx"
   5 #include "Loop.hxx"
   6 #include "Switch.hxx"
   7 #include "RuntimeSALOME.hxx"
   8 #include "CppNode.hxx"
   9 #include "PythonNode.hxx"
  10 #include "CORBANode.hxx"
  11 #include "XMLNode.hxx"
  12 #include "TypeConversions.hxx"
  13 #include "CORBACORBAConv.hxx"
  14 #include "PythonCORBAConv.hxx"
  15 #include "CORBAPythonConv.hxx"
  16 #include "CORBAXMLConv.hxx"
  17
  18 #include "runtimeTest.hxx"
  19
  20 #include <omniORB4/CORBA.h>
  21
  22 #include <iostream>
  23 #include <sstream>
  24 #include <string>
  25 #include <list>
  26 #include <vector>
  27 #include <map>
  28
  29 using namespace YACS::ENGINE;
  30 using namespace YACS;
  31 using namespace std;
  32
  33 #define _DEVDEBUG_
  34 #ifdef _DEVDEBUG_
  35 #define MYDEBTRACE {std::cerr << __FILE__ << " [" << __LINE__ << "] : ";}
  36 #define DEBTRACE(msg) {MYDEBTRACE; std::cerr<<msg<<std::endl<<std::flush;}
  37 #else
  38 #define MYDEBTRACE
  39 #define DEBTRACE(msg)
  40 #endif
  41
  42
  43 void RuntimeTest::setUp()
  44 {
  45 }
  46
  47 void RuntimeTest::tearDown()
  48 {
  49 }
  50
  51 void RuntimeTest::test1()
  52 {
  53   // --- init runtime
  54
  55   RuntimeSALOME::setRuntime();
  56
  57   Runtime *myRuntime = getRuntime();
  58
  59   // --- init typecodes
  60
  61   TypeCode *tc_double    = new TypeCode(Double);
  62   TypeCode *tc_int       = new TypeCode(Int);
  63   TypeCode *tc_string    = new TypeCode(String);
  64   TypeCode *tc           = TypeCode::interface_tc("id","name");
  65   TypeCode *tc_obj       = TypeCode::interface_tc("eo:Obj","Obj");
  66   DEBTRACE( " " << tc->id() << " " << tc->name() );
  67   TypeCode *tc_seqdble   = TypeCode::sequence_tc("eo:seqdouble","seqdouble",tc_double);
  68   TypeCode *tc_seqstr    = TypeCode::sequence_tc("eo:seqstring","seqstring",tc_string);
  69   TypeCode *tc_seqlong   = TypeCode::sequence_tc("eo:seqlong","seqlong",tc_int);
  70   TypeCode *tc_seqobj    = TypeCode::sequence_tc("eo:seqobj","seqobj",tc_obj);
  71   TypeCode *tc_seqseqdble= TypeCode::sequence_tc("eo:seqseqdble","seqseqdble",tc_seqdble);
  72   TypeCode *tc_seqseqobj = TypeCode::sequence_tc("eo:seqseqobj","seqseqobj",tc_seqobj);
  73   std::list<TypeCode_objref *> ltc;
  74   ltc.push_back((TypeCode_objref *)tc_obj);
  75   TypeCode *tc_C         = TypeCode::interface_tc("eo:C","C",ltc);
  76   TypeCode *tc_seqC      = TypeCode::sequence_tc("eo:seqC","seqC",tc_C);
  77
  78   DEBTRACE("int is a int: ");                CPPUNIT_ASSERT( tc_int->is_a(tc_int));
  79   DEBTRACE("seqdble is not a seqlong: ");    CPPUNIT_ASSERT(!tc_seqdble->is_a(tc_seqlong));
  80   DEBTRACE("seqdble is a seqdble: ");        CPPUNIT_ASSERT( tc_seqdble->is_a(tc_seqdble));
  81   DEBTRACE("seqlong is not a seqdble: ");    CPPUNIT_ASSERT(!tc_seqlong->is_a(tc_seqdble));
  82   DEBTRACE("C is a Obj: ");                  CPPUNIT_ASSERT( tc_C->is_a(tc_obj));
  83   DEBTRACE("Obj is not a C: " );             CPPUNIT_ASSERT(!tc_obj->is_a(tc_C));
  84   DEBTRACE("seqC is a seqObj: ");            CPPUNIT_ASSERT( tc_seqC->is_a(tc_seqobj));
  85   DEBTRACE( "seqObj is not a seqC: ");       CPPUNIT_ASSERT(!tc_seqobj->is_a(tc_seqC));
  86
  87   map<string, Node*> nodeMap;
  88   int inode = 0;
  89
  90   // --- Nodes 0 a 4 : Python
  91
  92   for (int i=0; i<5; i++)
  93     {
  94       ostringstream ss;
  95       ss << "Node_" << inode++;
  96       string s = ss.str();
  97       ElementaryNode* node = myRuntime->createNode("Python",s);
  98       nodeMap[s] = node;
  99       InputPort  *i1  = node->edAddInputPort("id1",  tc_double);
 100       InputPort  *i2  = node->edAddInputPort("ii2",  tc_int);
 101       InputPort  *i3  = node->edAddInputPort("is3",  tc_string);
 102       InputPort  *i4  = node->edAddInputPort("io4",  tc_obj);
 103       InputPort  *i5  = node->edAddInputPort("isd5", tc_seqdble);
 104       InputPort  *i6  = node->edAddInputPort("isl6", tc_seqlong);
 105       InputPort  *i7  = node->edAddInputPort("iso7", tc_seqobj);
 106       InputPort  *i8  = node->edAddInputPort("issd8",tc_seqseqdble);
 107       InputPort  *i9  = node->edAddInputPort("isso9",tc_seqseqobj);
 108       InputPort  *i10 = node->edAddInputPort("iC10", tc_C);
 109       InputPort  *i11 = node->edAddInputPort("isC11",tc_seqC);
 110
 111       OutputPort  *o1  = node->edAddOutputPort("od1",  tc_double);
 112       OutputPort  *o2  = node->edAddOutputPort("oi2",  tc_int);
 113       OutputPort  *o3  = node->edAddOutputPort("os3",  tc_string);
 114       OutputPort  *o4  = node->edAddOutputPort("oo4",  tc_obj);
 115       OutputPort  *o5  = node->edAddOutputPort("osd5", tc_seqdble);
 116       OutputPort  *o6  = node->edAddOutputPort("osl6", tc_seqlong);
 117       OutputPort  *o7  = node->edAddOutputPort("oso7", tc_seqobj);
 118       OutputPort  *o8  = node->edAddOutputPort("ossd8",tc_seqseqdble);
 119       OutputPort  *o9  = node->edAddOutputPort("osso9",tc_seqseqobj);
 120       OutputPort  *o10 = node->edAddOutputPort("oC10", tc_C);
 121       OutputPort  *o11 = node->edAddOutputPort("osC11",tc_seqC);
 122     }
 123
 124   // --- Nodes 5 a 9 : CORBA
 125
 126   for (int i=5; i<10; i++)
 127     {
 128       ostringstream ss;
 129       ss << "Node_" << inode++;
 130       string s = ss.str();
 131       ElementaryNode* node = myRuntime->createNode("CORBA",s);
 132       nodeMap[s] = node;
 133       InputPort  *i1  = node->edAddInputPort("id1",  tc_double);
 134       InputPort  *i2  = node->edAddInputPort("ii2",  tc_int);
 135       InputPort  *i3  = node->edAddInputPort("is3",  tc_string);
 136       InputPort  *i4  = node->edAddInputPort("io4",  tc_obj);
 137       InputPort  *i5  = node->edAddInputPort("isd5", tc_seqdble);
 138       InputPort  *i6  = node->edAddInputPort("isl6", tc_seqlong);
 139       InputPort  *i7  = node->edAddInputPort("iso7", tc_seqobj);
 140       InputPort  *i8  = node->edAddInputPort("issd8",tc_seqseqdble);
 141       InputPort  *i9  = node->edAddInputPort("isso9",tc_seqseqobj);
 142       InputPort  *i10 = node->edAddInputPort("iC10", tc_C);
 143       InputPort  *i11 = node->edAddInputPort("isC11",tc_seqC);
 144
 145       OutputPort  *o1  = node->edAddOutputPort("od1",  tc_double);
 146       OutputPort  *o2  = node->edAddOutputPort("oi2",  tc_int);
 147       OutputPort  *o3  = node->edAddOutputPort("os3",  tc_string);
 148       OutputPort  *o4  = node->edAddOutputPort("oo4",  tc_obj);
 149       OutputPort  *o5  = node->edAddOutputPort("osd5", tc_seqdble);
 150       OutputPort  *o6  = node->edAddOutputPort("osl6", tc_seqlong);
 151       OutputPort  *o7  = node->edAddOutputPort("oso7", tc_seqobj);
 152       OutputPort  *o8  = node->edAddOutputPort("ossd8",tc_seqseqdble);
 153       OutputPort  *o9  = node->edAddOutputPort("osso9",tc_seqseqobj);
 154       OutputPort  *o10 = node->edAddOutputPort("oC10", tc_C);
 155       OutputPort  *o11 = node->edAddOutputPort("osC11",tc_seqC);
 156     }
 157
 158   DEBTRACE(" --- create bloc, add two nodes, check constituants" );
 159
 160   map<string, Bloc*> blocMap;
 161   int ibloc = 0;
 162
 163   // --- Bloc_0 with Node_0 and Node_1
 164   {
 165     ostringstream ss;
 166     ss << "Bloc_" << ibloc++;
 167     string s = ss.str();
 168     Bloc* bloc = new Bloc(s);
 169     nodeMap[s] = bloc;
 170     blocMap[s] = bloc;
 171     bloc->edAddChild(nodeMap["Node_0"]);
 172     bloc->edAddChild(nodeMap["Node_1"]);
 173     {
 174       set<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
 175       CPPUNIT_ASSERT(setelem.size() == 2);
 176     }
 177   }
 178
 179   // --- Bloc_1 with Node_2
 180   {
 181     ostringstream ss;
 182     ss << "Bloc_" << ibloc++;
 183     string s = ss.str();
 184     Bloc* bloc = new Bloc(s);
 185     nodeMap[s] = bloc;
 186     blocMap[s] = bloc;
 187     bloc->edAddChild(nodeMap["Node_2"]);
 188   }
 189
 190   DEBTRACE(" --- add a node already used in the bloc does nothing (return false)" );
 191   CPPUNIT_ASSERT( ! blocMap["Bloc_0"]->edAddChild(nodeMap["Node_1"]));
 192
 193   DEBTRACE(" --- add a node already used elsewhere raises exception " );
 194   CPPUNIT_ASSERT_THROW(blocMap["Bloc_1"]->edAddChild(nodeMap["Node_1"]),
 195                        YACS::Exception);
 196
 197
 198   DEBTRACE(" --- recursive blocs, check constituants" );
 199
 200   // --- Bloc_2 with Bloc_1 and Bloc_2
 201   {
 202     ostringstream ss;
 203     ss << "Bloc_" << ibloc++;
 204     string s = ss.str();
 205     Bloc* bloc = new Bloc(s);
 206     nodeMap[s] = bloc;
 207     blocMap[s] = bloc;
 208     bloc->edAddChild(nodeMap["Bloc_0"]);  // 2 elementary nodes
 209     bloc->edAddChild(nodeMap["Bloc_1"]);  // 1 elementary node
 210     bloc->edAddChild(nodeMap["Node_3"]);   // 1 elementary node
 211   }
 212
 213   {
 214     set<ElementaryNode *> setelem = blocMap["Bloc_2"]->getRecursiveConstituents();
 215     CPPUNIT_ASSERT(setelem.size() == 4);
 216     for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 217       {
 218         DEBTRACE("     elem name = " << (*it)->getName());
 219       }
 220   }
 221
 222
 223   DEBTRACE(" --- create and delete data links" );
 224
 225   CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 226   CPPUNIT_ASSERT_THROW(blocMap["Bloc_0"]->edAddLink(nodeMap["Node_0"]->getOutputPort("od1"),
 227                                                     nodeMap["Node_1"]->getInputPort("is3")),
 228                        YACS::ENGINE::ConversionException);
 229   CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 230
 231   blocMap["Bloc_0"]->edAddLink(nodeMap["Node_0"]->getOutputPort("oi2"),
 232                                nodeMap["Node_1"]->getInputPort("ii2"));
 233   CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 21);
 234
 235   blocMap["Bloc_0"]->edRemoveLink(nodeMap["Node_0"]->getOutputPort("oi2"),
 236                                   nodeMap["Node_1"]->getInputPort("ii2"));
 237   CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 238
 239
 240   DEBTRACE(" --- create python nodes with scripts" );
 241
 242   // --- Node 10 : Python
 243
 244   {
 245     ostringstream ss;
 246     ss << "Node_" << inode++;
 247     string s = ss.str();
 248     ElementaryNode* node = myRuntime->createNode("Python",s);
 249     nodeMap[s] = node;
 250     ((PythonNode*) node)->set_script("a=a+1\n");
 251     InputPort  *i1  = node->edAddInputPort("a",  tc_double);
 252     OutputPort *o1  = node->edAddOutputPort("a", tc_double);
 253   }
 254
 255   // --- Node 11 : Python
 256
 257   {
 258     ostringstream ss;
 259     ss << "Node_" << inode++;
 260     string s = ss.str();
 261     ElementaryNode* node = myRuntime->createNode("Python",s);
 262     nodeMap[s] = node;
 263     ((PythonNode*) node)->set_script("a=b+1\n"
 264                                      "c=2*a\n"
 265                                      "i=10\n"
 266                                      "s='aaaaaaa'\n"
 267                                      "seqdble=[1.5,2.4]\n"
 268                                      "lngvec=[1,2]\n"
 269                                      "dblevecvec=[[1.5,2.4],[6.7,7.8]]\n"
 270                                      );
 271     InputPort  *i1  = node->edAddInputPort("b",            tc_double);
 272     OutputPort *o1  = node->edAddOutputPort("c",           tc_double);
 273     OutputPort *o2  = node->edAddOutputPort("i",           tc_int);
 274     OutputPort *o3  = node->edAddOutputPort("s",           tc_string);
 275     OutputPort *o4  = node->edAddOutputPort("seqdble",     tc_seqdble);
 276     OutputPort *o5  = node->edAddOutputPort("dblevecvec",  tc_seqseqdble);
 277     OutputPort *o6  = node->edAddOutputPort("lngvec",      tc_seqlong);
 278   }
 279
 280   // --- Node 12 : Python
 281
 282   {
 283     ostringstream ss;
 284     ss << "Node_" << inode++;
 285     string s = ss.str();
 286     ElementaryNode* node = myRuntime->createNode("Python",s);
 287     nodeMap[s] = node;
 288     ((PythonNode*) node)->set_script("a=dble+1\n"
 289                                      "dble=2*a\n"
 290                                      );
 291     InputPort  *i1  = node->edAddInputPort("dble",  tc_double);
 292     OutputPort *o1  = node->edAddOutputPort("dble", tc_double);
 293   }
 294
 295   // --- Node 13 : Python
 296
 297   {
 298     ostringstream ss;
 299     ss << "Node_" << inode++;
 300     string s = ss.str();
 301     ElementaryNode* node = myRuntime->createNode("Python",s);
 302     nodeMap[s] = node;
 303     ((PythonNode*) node)->set_script("print 'node 13'\n"
 304                                      "import eo\n"
 305                                      "print ob\n"
 306                                      "o=ob._narrow(eo.Obj)\n"
 307                                      "print o\n"
 308                                      "print o.echoLong(13)\n"
 309                                      "a=dble+1\n"
 310                                      "dble=2*a\n"
 311                                      "print lng\n"
 312                                      "print '++++++++',s,'+++++++++++++'\n"
 313                                      "ob=o\n"
 314                                      "seqstr=['aaa','bbb']\n"
 315                                      "seqobj=[o,o,o,o]\n"
 316                                      "seqseqobj=[[o,o],[o,o]]\n"
 317                                      );
 318
 319     InputPort  *i1  = node->edAddInputPort("dble",  tc_double);
 320     InputPort  *i2  = node->edAddInputPort("lng",   tc_int);
 321     InputPort  *i3  = node->edAddInputPort("s",     tc_string);
 322     InputPort  *i4  = node->edAddInputPort("ob",    tc_obj);
 323     OutputPort *o1  = node->edAddOutputPort("dble",       tc_double);
 324     OutputPort *o2  = node->edAddOutputPort("s",          tc_string);
 325     OutputPort *o3  = node->edAddOutputPort("lng",        tc_int);
 326     OutputPort *o4  = node->edAddOutputPort("ob",         tc_obj);
 327     OutputPort *o5  = node->edAddOutputPort("seqstr",     tc_seqstr);
 328     OutputPort *o6  = node->edAddOutputPort("seqobj",     tc_seqobj);
 329     OutputPort *o7  = node->edAddOutputPort("seqseqobj",  tc_seqseqobj);
 330   }
 331
 332   // --- Node 14 : Python
 333
 334   {
 335     ostringstream ss;
 336     ss << "Node_" << inode++;
 337     string s = ss.str();
 338     ElementaryNode* node = myRuntime->createNode("Python",s);
 339     nodeMap[s] = node;
 340     ((PythonNode*) node)->set_script("print li\n"
 341                                      "print 'lili=',lili\n"
 342                                      "print 'lstr=',lstr\n"
 343                                      "print 'lobj=',lobj\n"
 344                                      "print 'llobj=',llobj\n"
 345                                      "print 'objc=',objc\n"
 346                                      "li=2*li\n"
 347                                      );
 348     InputPort  *i1  = node->edAddInputPort("li",    tc_seqdble);
 349     InputPort  *i2  = node->edAddInputPort("lili",  tc_seqseqdble);
 350     InputPort  *i3  = node->edAddInputPort("lstr",  tc_seqstr);
 351     InputPort  *i4  = node->edAddInputPort("lobj",  tc_seqobj);
 352     InputPort  *i5  = node->edAddInputPort("llobj", tc_seqseqobj);
 353     InputPort  *i6  = node->edAddInputPort("objc",  tc_C);
 354     OutputPort *o1  = node->edAddOutputPort("li",   tc_seqdble);
 355     OutputPort *o2  = node->edAddOutputPort("objc", tc_C);
 356   }
 357
 358   // --- Node 15 : Python
 359
 360   {
 361     ostringstream ss;
 362     ss << "Node_" << inode++;
 363     string s = ss.str();
 364     ElementaryNode* node = myRuntime->createNode("Python",s);
 365     nodeMap[s] = node;
 366     ((PythonNode*) node)->set_script("print li\n"
 367                                      "li=[2*e for e in li]\n"
 368                                      "print 'obj=',obj\n"
 369                                      "print li\n"
 370                                      "print lngvec\n"
 371                                      "print dblevec\n"
 372                                      );
 373     InputPort  *i1  = node->edAddInputPort("li",      tc_seqdble);
 374     InputPort  *i2  = node->edAddInputPort("obj",     tc_obj);
 375     InputPort  *i3  = node->edAddInputPort("lngvec",  tc_seqlong);
 376     InputPort  *i4  = node->edAddInputPort("dblevec", tc_seqdble);
 377     OutputPort *o1  = node->edAddOutputPort("li",     tc_seqdble);
 378   }
 379
 380   DEBTRACE(" --- create CORBA nodes" );
 381
 382   // --- Node 16 : CORBA
 383
 384   {
 385     ostringstream ss;
 386     ss << "Node_" << inode++;
 387     string s = ss.str();
 388     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 389     nodeMap[s] = node;
 390     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 391     ((CORBANode *) node)->set_method("echoDouble");
 392     InputPort  *i1  = node->edAddInputPort("a",  tc_double);
 393     OutputPort *o1  = node->edAddOutputPort("c", tc_double);
 394   }
 395
 396   // --- Node 17 - 18 : CORBA
 397
 398   for (int i =0; i <2; i++)
 399     {
 400       ostringstream ss;
 401       ss << "Node_" << inode++;
 402       string s = ss.str();
 403       ElementaryNode* node = myRuntime->createNode("CORBA",s);
 404       nodeMap[s] = node;
 405       ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 406       ((CORBANode *) node)->set_method("echoDouble");
 407       InputPort  *i1  = node->edAddInputPort("b",  tc_double);
 408       OutputPort *o1  = node->edAddOutputPort("c", tc_double);
 409     }
 410
 411   // --- Node 19 : CORBA
 412
 413   {
 414     ostringstream ss;
 415     ss << "Node_" << inode++;
 416     string s = ss.str();
 417     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 418     nodeMap[s] = node;
 419     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 420     ((CORBANode *) node)->set_method("createObj");
 421     InputPort  *i1  = node->edAddInputPort("long",  tc_int);
 422     OutputPort *o1  = node->edAddOutputPort("obj",  tc_obj);
 423   }
 424
 425   // --- Node 20, 21, 22 : CORBA
 426
 427   for (int i =0; i <3; i++)
 428     {
 429       ostringstream ss;
 430       ss << "Node_" << inode++;
 431       string s = ss.str();
 432       ElementaryNode* node = myRuntime->createNode("CORBA",s);
 433       nodeMap[s] = node;
 434       ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 435       ((CORBANode *) node)->set_method("echoAll");
 436       InputPort  *i1  = node->edAddInputPort("double",  tc_double);
 437       InputPort  *i2  = node->edAddInputPort("long",    tc_int);
 438       InputPort  *i3  = node->edAddInputPort("str",     tc_string);
 439       InputPort  *i4  = node->edAddInputPort("obj",     tc_obj);
 440       OutputPort *o1  = node->edAddOutputPort("double", tc_double);
 441       OutputPort *o2  = node->edAddOutputPort("long",   tc_int);
 442       OutputPort *o3  = node->edAddOutputPort("str",    tc_string);
 443       OutputPort *o4  = node->edAddOutputPort("obj",    tc_obj);
 444     }
 445
 446   // --- Node 23 a 26 : CORBA
 447
 448   for (int i =0; i <4; i++)
 449     {
 450       ostringstream ss;
 451       ss << "Node_" << inode++;
 452       string s = ss.str();
 453       ElementaryNode* node = myRuntime->createNode("CORBA",s);
 454       nodeMap[s] = node;
 455       ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 456       ((CORBANode *) node)->set_method("echoDoubleVec");
 457       InputPort  *i1  = node->edAddInputPort("dblevec",  tc_seqdble);
 458       OutputPort *o1  = node->edAddOutputPort("dblevec", tc_seqdble);
 459     }
 460
 461   // --- Node 27 : CORBA
 462
 463   {
 464     ostringstream ss;
 465     ss << "Node_" << inode++;
 466     string s = ss.str();
 467     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 468     nodeMap[s] = node;
 469     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 470     ((CORBANode *) node)->set_method("echoStrVec");
 471     InputPort  *i1  = node->edAddInputPort("strvec",  tc_seqstr);
 472     OutputPort *o1  = node->edAddOutputPort("strvec", tc_seqstr);
 473   }
 474
 475   // --- Node 28 : CORBA
 476
 477   {
 478     ostringstream ss;
 479     ss << "Node_" << inode++;
 480     string s = ss.str();
 481     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 482     nodeMap[s] = node;
 483     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 484     ((CORBANode *) node)->set_method("echoObjectVec");
 485     InputPort  *i1  = node->edAddInputPort("objvec",  tc_seqobj);
 486     OutputPort *o1  = node->edAddOutputPort("objvec", tc_seqobj);
 487   }
 488
 489   // --- Node 29 : CORBA
 490
 491   {
 492     ostringstream ss;
 493     ss << "Node_" << inode++;
 494     string s = ss.str();
 495     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 496     nodeMap[s] = node;
 497     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 498     ((CORBANode *) node)->set_method("echoDoubleVecVec");
 499     InputPort  *i1  = node->edAddInputPort("dblevecvec",  tc_seqseqdble);
 500     OutputPort *o1  = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
 501   }
 502
 503   // --- Node 30 : CORBA
 504
 505   {
 506     ostringstream ss;
 507     ss << "Node_" << inode++;
 508     string s = ss.str();
 509     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 510     nodeMap[s] = node;
 511     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 512     ((CORBANode *) node)->set_method("echoObjectVecVec");
 513     InputPort  *i1  = node->edAddInputPort("objvecvec",  tc_seqseqobj);
 514     OutputPort *o1  = node->edAddOutputPort("objvecvec", tc_seqseqobj);
 515   }
 516
 517   // --- Node 31 : CORBA
 518
 519   {
 520     ostringstream ss;
 521     ss << "Node_" << inode++;
 522     string s = ss.str();
 523     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 524     nodeMap[s] = node;
 525     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 526     ((CORBANode *) node)->set_method("echoIntVec");
 527     InputPort  *i1  = node->edAddInputPort("lngvec",  tc_seqlong);
 528     OutputPort *o1  = node->edAddOutputPort("lngvec", tc_seqlong);
 529   }
 530
 531   // --- Node 32 : CORBA
 532
 533   {
 534     ostringstream ss;
 535     ss << "Node_" << inode++;
 536     string s = ss.str();
 537     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 538     nodeMap[s] = node;
 539     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 540     ((CORBANode *) node)->set_method("createC");
 541     OutputPort *o1  = node->edAddOutputPort("objc", tc_C);
 542   }
 543
 544   // --- Node 33 : CORBA
 545
 546   {
 547     ostringstream ss;
 548     ss << "Node_" << inode++;
 549     string s = ss.str();
 550     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 551     nodeMap[s] = node;
 552     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 553     ((CORBANode *) node)->set_method("echoDouble");
 554     InputPort  *i1  = node->edAddInputPort("dble",  tc_double);
 555     OutputPort *o1  = node->edAddOutputPort("dble", tc_double);
 556   }
 557
 558   // --- Node 34 : CORBA
 559
 560   {
 561     ostringstream ss;
 562     ss << "Node_" << inode++;
 563     string s = ss.str();
 564     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 565     nodeMap[s] = node;
 566     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 567     ((CORBANode *) node)->set_method("echoDoubleVec");
 568     InputPort  *i1  = node->edAddInputPort("dblevec",  tc_seqdble);
 569     OutputPort *o1  = node->edAddOutputPort("dblevec", tc_seqdble);
 570   }
 571
 572   // --- Node 35 : CORBA
 573
 574   {
 575     ostringstream ss;
 576     ss << "Node_" << inode++;
 577     string s = ss.str();
 578     ElementaryNode* node = myRuntime->createNode("CORBA",s);
 579     nodeMap[s] = node;
 580     ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
 581     ((CORBANode *) node)->set_method("echoDoubleVecVec");
 582     InputPort  *i1  = node->edAddInputPort("dblevecvec",  tc_seqseqdble);
 583     OutputPort *o1  = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
 584   }
 585
 586   DEBTRACE(" --- create XML nodes" );
 587
 588   // --- Node 36 : XML
 589
 590   {
 591     ostringstream ss;
 592     ss << "Node_" << inode++;
 593     string s = ss.str();
 594     ElementaryNode* node = myRuntime->createNode("XML",s);
 595     nodeMap[s] = node;
 596     ((XmlNode *) node)->set_script("./xmlrun.sh");
 597     InputPort  *i1  = node->edAddInputPort("dble",  tc_double);
 598     InputPort  *i2  = node->edAddInputPort("dblevec",  tc_seqdble);
 599     InputPort  *i3  = node->edAddInputPort("dblevecvec",  tc_seqseqdble);
 600     OutputPort *o1  = node->edAddOutputPort("dble", tc_double);
 601     OutputPort *o2  = node->edAddOutputPort("dblevec", tc_seqdble);
 602     OutputPort *o3  = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
 603   }
 604
 605   DEBTRACE(" --- create Bloc with all nodes" );
 606
 607   // --- Bloc_3 with Node_10 and following
 608
 609   {
 610     ostringstream ss;
 611     ss << "Bloc_" << ibloc++;
 612     string s = ss.str();
 613     Bloc* bloc = new Bloc(s);
 614     nodeMap[s] = bloc;
 615     blocMap[s] = bloc;
 616     for (int i=10; i<inode; i++)
 617       {
 618         ostringstream ssn;
 619         ssn << "Node_" << i;
 620         string sn = ssn.str();
 621         cerr << sn << endl;
 622         bloc->edAddChild(nodeMap[sn]);
 623       }
 624   }
 625
 626   DEBTRACE(" --- create data links, python to python" );
 627
 628
 629   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_10"]->getOutputPort("a"),
 630                                nodeMap["Node_11"]->getInputPort("b"));
 631
 632
 633   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_10"]->getOutputPort("a"),
 634                                nodeMap["Node_12"]->getInputPort("dble"));
 635
 636   // Python sequence<double> -> Python sequence<double>
 637   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_14"]->getOutputPort("li"),
 638                                nodeMap["Node_15"]->getInputPort("li"));
 639
 640   // Python obj C -> Python obj Obj : OK bon sens
 641   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_14"]->getOutputPort("objc"),
 642                                nodeMap["Node_15"]->getInputPort("obj"));
 643
 644   // Python Obj -> Python C (dérivé de Obj) : interdit
 645   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
 646                                                     nodeMap["Node_14"]->getInputPort("objc")),
 647                        YACS::ENGINE::ConversionException);
 648
 649   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("s"),
 650                                                     nodeMap["Node_12"]->getInputPort("dble")),
 651                        YACS::ENGINE::ConversionException);
 652
 653   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
 654                                                     nodeMap["Node_12"]->getInputPort("dble")),
 655                        YACS::ENGINE::ConversionException);
 656
 657   DEBTRACE(" --- create data links, python to CORBA" );
 658
 659   // double->double
 660   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("c"),
 661                                nodeMap["Node_16"]->getInputPort("a"));
 662
 663   // int->int
 664   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("i"),
 665                                nodeMap["Node_19"]->getInputPort("long"));
 666
 667   // str->str
 668   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("s"),
 669                                nodeMap["Node_20"]->getInputPort("str"));
 670
 671   // seq<long> -> seq<double>
 672   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("lngvec"),
 673                                nodeMap["Node_23"]->getInputPort("dblevec"));
 674
 675   // seq<long> -> seq<long>
 676   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("lngvec"),
 677                                nodeMap["Node_31"]->getInputPort("lngvec"));
 678
 679   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
 680                                nodeMap["Node_22"]->getInputPort("obj"));
 681
 682   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
 683                                nodeMap["Node_26"]->getInputPort("dblevec"));
 684
 685   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqstr"),
 686                                nodeMap["Node_27"]->getInputPort("strvec"));
 687
 688   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqobj"),
 689                                nodeMap["Node_28"]->getInputPort("objvec"));
 690
 691   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("dblevecvec"),
 692                                nodeMap["Node_29"]->getInputPort("dblevecvec"));
 693
 694   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqseqobj"),
 695                                nodeMap["Node_30"]->getInputPort("objvecvec"));
 696
 697   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
 698                                                     nodeMap["Node_27"]->getInputPort("strvec")),
 699                        YACS::ENGINE::ConversionException);
 700
 701   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
 702                                                     nodeMap["Node_22"]->getInputPort("str")),
 703                        YACS::ENGINE::ConversionException);
 704
 705   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
 706                                                     nodeMap["Node_22"]->getInputPort("str")),
 707                        YACS::ENGINE::ConversionException);
 708
 709   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("lng"),
 710                                                     nodeMap["Node_22"]->getInputPort("str")),
 711                        YACS::ENGINE::ConversionException);
 712
 713   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
 714                                                     nodeMap["Node_22"]->getInputPort("long")),
 715                        YACS::ENGINE::ConversionException);
 716
 717   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
 718                                                     nodeMap["Node_24"]->getInputPort("dblevec")),
 719                        YACS::ENGINE::ConversionException);
 720
 721   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("dblevecvec"),
 722                                                     nodeMap["Node_24"]->getInputPort("dblevec")),
 723                        YACS::ENGINE::ConversionException);
 724
 725   CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqstr"),
 726                                                     nodeMap["Node_24"]->getInputPort("dblevec")),
 727                        YACS::ENGINE::ConversionException);
 728
 729   DEBTRACE(" --- create data links, CORBA to CORBA" );
 730
 731   // double->double
 732   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
 733                                nodeMap["Node_17"]->getInputPort("b"));
 734
 735   // double->double
 736   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
 737                                nodeMap["Node_18"]->getInputPort("b"));
 738
 739   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_19"]->getOutputPort("obj"),
 740                                nodeMap["Node_20"]->getInputPort("obj"));
 741
 742   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_18"]->getOutputPort("c"),
 743                                nodeMap["Node_20"]->getInputPort("double"));
 744
 745   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
 746                                nodeMap["Node_21"]->getInputPort("double"));
 747
 748   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
 749                                nodeMap["Node_21"]->getInputPort("long"));
 750
 751   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("str"),
 752                                nodeMap["Node_21"]->getInputPort("str"));
 753
 754   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("obj"),
 755                                nodeMap["Node_21"]->getInputPort("obj"));
 756
 757   // Corba sequence<double> -> Corba sequence<double>
 758   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_23"]->getOutputPort("dblevec"),
 759                                nodeMap["Node_24"]->getInputPort("dblevec"));
 760
 761   // Corba sequence<double> -> Corba sequence<double>
 762   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
 763                                nodeMap["Node_25"]->getInputPort("dblevec"));
 764
 765
 766   DEBTRACE(" --- create data links, CORBA to Python" );
 767
 768
 769   // Corba C -> Python C (dérivé de Obj):OK
 770   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_32"]->getOutputPort("objc"),
 771                                nodeMap["Node_14"]->getInputPort("objc"));
 772
 773   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("double"),
 774                                nodeMap["Node_13"]->getInputPort("dble"));
 775
 776   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("long"),
 777                                nodeMap["Node_13"]->getInputPort("lng"));
 778
 779   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("str"),
 780                                nodeMap["Node_13"]->getInputPort("s"));
 781
 782   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("obj"),
 783                                nodeMap["Node_13"]->getInputPort("ob"));
 784
 785   // Corba sequence<double> -> Python sequence<double>
 786   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_23"]->getOutputPort("dblevec"),
 787                                nodeMap["Node_14"]->getInputPort("li"));
 788
 789   // Corba sequence<sequence<double>> -> Python sequence<sequence<double>>
 790   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_29"]->getOutputPort("dblevecvec"),
 791                                nodeMap["Node_14"]->getInputPort("lili"));
 792
 793   // Corba sequence<object> -> Python sequence<object>
 794   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_28"]->getOutputPort("objvec"),
 795                                nodeMap["Node_14"]->getInputPort("lobj"));
 796
 797   // Corba sequence<string> -> Python sequence<string>
 798   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_27"]->getOutputPort("strvec"),
 799                                nodeMap["Node_14"]->getInputPort("lstr"));
 800
 801   // Corba sequence<object> -> Python sequence<object>
 802   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_30"]->getOutputPort("objvecvec"),
 803                                nodeMap["Node_14"]->getInputPort("llobj"));
 804
 805   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
 806                                nodeMap["Node_15"]->getInputPort("lngvec"));
 807
 808   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
 809                                nodeMap["Node_15"]->getInputPort("dblevec"));
 810
 811   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
 812                                nodeMap["Node_22"]->getInputPort("double"));
 813
 814   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
 815                                nodeMap["Node_22"]->getInputPort("long"));
 816
 817   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("str"),
 818                                nodeMap["Node_22"]->getInputPort("str"));
 819
 820  DEBTRACE(" --- create data links, xml nodes" );
 821
 822   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
 823                                nodeMap["Node_36"]->getInputPort("dble"));
 824
 825   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_26"]->getOutputPort("dblevec"),
 826                                nodeMap["Node_36"]->getInputPort("dblevec"));
 827
 828   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_29"]->getOutputPort("dblevecvec"),
 829                                nodeMap["Node_36"]->getInputPort("dblevecvec"));
 830
 831   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dble"),
 832                                nodeMap["Node_33"]->getInputPort("dble"));
 833
 834   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dblevec"),
 835                                nodeMap["Node_34"]->getInputPort("dblevec"));
 836
 837   blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dblevecvec"),
 838                                nodeMap["Node_35"]->getInputPort("dblevecvec"));
 839
 840   DEBTRACE(" --- initialization" );
 841
 842   PyObject *pyDouble = PyFloat_FromDouble(10.51);
 843   nodeMap["Node_10"]->getInputPort("a")->put(pyDouble);
 844
 845   CORBA::Any a;
 846   a <<= (CORBA::Double) 3.14;
 847
 848   CORBA::Any anyLong;
 849   anyLong <<= (CORBA::Long) 1;
 850
 851   CORBA::Any anyLong2;
 852   anyLong2 <<= (CORBA::Long) 1;
 853   nodeMap["Node_20"]->getInputPort("long")->put(&anyLong2);
 854
 855   CORBA::Any aString;
 856   aString <<= (const char *)"texte";
 857   nodeMap["Node_20"]->getInputPort("str")->put(&aString);
 858
 859
 860   DEBTRACE(" --- execution Python Node_10" );
 861   ((ElementaryNode*)nodeMap["Node_10"])->execute();
 862
 863   DEBTRACE(" --- execution Python Node_11" );
 864   ((ElementaryNode*)nodeMap["Node_11"])->execute();
 865
 866   DEBTRACE(" --- execution Python Node_12" );
 867   ((ElementaryNode*)nodeMap["Node_12"])->execute();
 868
 869   DEBTRACE(" --- execution CORBA Node_16" );
 870   ((ElementaryNode*)nodeMap["Node_16"])->execute();
 871
 872   DEBTRACE(" --- execution CORBA Node_17" );
 873   ((ElementaryNode*)nodeMap["Node_17"])->execute();
 874
 875   DEBTRACE(" --- execution CORBA Node_18" );
 876   ((ElementaryNode*)nodeMap["Node_18"])->execute();
 877
 878   DEBTRACE(" --- execution CORBA Node_19" );
 879   ((ElementaryNode*)nodeMap["Node_19"])->execute();
 880
 881   DEBTRACE(" --- execution CORBA Node_20" );
 882   ((ElementaryNode*)nodeMap["Node_20"])->execute();
 883
 884   DEBTRACE(" --- execution CORBA Node_21" );
 885   ((ElementaryNode*)nodeMap["Node_21"])->execute();
 886
 887   DEBTRACE(" --- execution CORBA Node_29" );
 888   ((ElementaryNode*)nodeMap["Node_29"])->execute();
 889
 890   DEBTRACE(" --- execution Python Node_13" );
 891   ((ElementaryNode*)nodeMap["Node_13"])->execute();
 892
 893   DEBTRACE(" --- execution CORBA Node_22" );
 894   ((ElementaryNode*)nodeMap["Node_22"])->execute();
 895
 896   DEBTRACE(" --- execution CORBA Node_23" );
 897   ((ElementaryNode*)nodeMap["Node_23"])->execute();
 898
 899   DEBTRACE(" --- execution CORBA Node_24" );
 900   ((ElementaryNode*)nodeMap["Node_24"])->execute();
 901
 902   DEBTRACE(" --- execution CORBA Node_27" );
 903   ((ElementaryNode*)nodeMap["Node_27"])->execute();
 904
 905   DEBTRACE(" --- execution CORBA Node_28" );
 906   ((ElementaryNode*)nodeMap["Node_28"])->execute();
 907
 908   DEBTRACE(" --- execution CORBA Node_30" );
 909   ((ElementaryNode*)nodeMap["Node_30"])->execute();
 910
 911   DEBTRACE(" --- execution CORBA Node_32" );
 912   ((ElementaryNode*)nodeMap["Node_32"])->execute();
 913
 914   DEBTRACE(" --- execution CORBA Node_26" );
 915   ((ElementaryNode*)nodeMap["Node_26"])->execute();
 916
 917   DEBTRACE(" --- execution CORBA Node_31" );
 918   ((ElementaryNode*)nodeMap["Node_31"])->execute();
 919
 920   DEBTRACE(" --- execution Python Node_14" );
 921   ((ElementaryNode*)nodeMap["Node_14"])->execute();
 922
 923   DEBTRACE(" --- execution Python Node_15" );
 924   ((ElementaryNode*)nodeMap["Node_15"])->execute();
 925
 926   DEBTRACE(" --- execution XML Node_36" );
 927   ((ElementaryNode*)nodeMap["Node_36"])->execute();
 928
 929   DEBTRACE(" --- execution CORBA Node_33" );
 930   ((ElementaryNode*)nodeMap["Node_33"])->execute();
 931
 932   DEBTRACE(" --- execution CORBA Node_34" );
 933   ((ElementaryNode*)nodeMap["Node_34"])->execute();
 934
 935   DEBTRACE(" --- execution CORBA Node_35" );
 936   ((ElementaryNode*)nodeMap["Node_35"])->execute();
 937
 938   DEBTRACE(" --- end of execution" );
 939
 940   CORBA::Double l;
 941   CORBA::Any* x;
 942
 943   PyObject *ob=((OutputPyPort*)nodeMap["Node_11"]->getOutputPort("c"))->get();
 944   DEBTRACE("ob refcnt: " << ob->ob_refcnt);
 945   PyObject_Print(ob,stdout,Py_PRINT_RAW);
 946
 947   DEBTRACE("a: " << &a);
 948   DEBTRACE("a.value(): " << a.value());
 949
 950   x= ((InputCorbaPort*)nodeMap["Node_16"]->getInputPort("a"))->getAny();
 951   DEBTRACE("CORBA Node_16 input a any: " << x);
 952   *x >>= l;
 953   DEBTRACE("CORBA Node_16 input a double: " << l);
 954
 955   *((InputCorbaPort*)nodeMap["Node_17"]->getInputPort("b"))->getAny() >>= l;
 956   DEBTRACE("CORBA Node_17 input b double: " << l);
 957
 958   *((InputCorbaPort*)nodeMap["Node_18"]->getInputPort("b"))->getAny() >>= l;
 959   DEBTRACE("CORBA Node_18 input a double: " << l);
 960
 961   *((OutputCorbaPort*)nodeMap["Node_16"]->getOutputPort("c"))->getAny() >>= l;
 962   DEBTRACE("CORBA Node_16 output c double: " << l);
 963
 964   *((OutputCorbaPort*)nodeMap["Node_17"]->getOutputPort("c"))->getAny() >>= l;
 965   DEBTRACE("CORBA Node_17 output c double: " << l);
 966
 967   *((OutputCorbaPort*)nodeMap["Node_18"]->getOutputPort("c"))->getAny() >>= l;
 968   DEBTRACE("CORBA Node_18 output c double: " << l);
 969
 970   DEBTRACE(" --- fini" );
 971 }