src/runtime/Test/runtimeTest.cxx

   1 // Copyright (C) 2006-2022  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
  21 //
  22 #include "TypeConversions.hxx"
  23 #include "Bloc.hxx"
  24 #include "ElementaryNode.hxx"
  25 #include "Loop.hxx"
  26 #include "ForLoop.hxx"
  27 #include "Switch.hxx"
  28 #include "CppNode.hxx"
  29 #include "PythonNode.hxx"
  30 #include "InlineNode.hxx"
  31 #include "ServiceNode.hxx"
  32 #include "XMLNode.hxx"
  33 #include "PythonPorts.hxx"
  34 #include "XMLPorts.hxx"
  35 #include "CORBAPorts.hxx"
  36 #include "CppPorts.hxx"
  37 #include "CppComponent.hxx"
  38 #include "Executor.hxx"
  39
  40 #include "runtimeTest.hxx"
  41
  42 #include <iostream>
  43 #include <sstream>
  44 #include <string>
  45 #include <list>
  46 #include <vector>
  47 #include <map>
  48 #include <cctype>
  49 #include <cstdlib>
  50
  51 #define _DEVDEBUG_
  52 #include "YacsTrace.hxx"
  53
  54 using namespace YACS::ENGINE;
  55 using namespace YACS;
  56 using namespace std;
  57
  58 // --- init typecodes
  59
  60 TypeCode *RuntimeTest::_tc_double    = new TypeCode(Double);
  61 TypeCode *RuntimeTest::_tc_int       = new TypeCode(Int);
  62 TypeCode *RuntimeTest::_tc_string    = new TypeCode(String);
  63 TypeCode *RuntimeTest::_tc           = TypeCode::interfaceTc("id","name");
  64 //TypeCode *RuntimeTest::_tc_obj    = TypeCode::interfaceTc("eo::Obj","IDL:eo/Obj:1.0");
  65 TypeCode *RuntimeTest::_tc_obj       = TypeCode::interfaceTc("IDL:eo/Obj:1.0","Obj");
  66 TypeCode *RuntimeTest::_tc_seqdble   = TypeCode::sequenceTc("eo:seqdouble","seqdouble",RuntimeTest::_tc_double);
  67 TypeCode *RuntimeTest::_tc_seqstr    = TypeCode::sequenceTc("eo:seqstring","seqstring",RuntimeTest::_tc_string);
  68 TypeCode *RuntimeTest::_tc_seqlong   = TypeCode::sequenceTc("eo:seqlong","seqlong",RuntimeTest::_tc_int);
  69 TypeCode *RuntimeTest::_tc_seqobj    = TypeCode::sequenceTc("eo:seqobj","seqobj",RuntimeTest::_tc_obj);
  70 TypeCode *RuntimeTest::_tc_seqseqdble= TypeCode::sequenceTc("eo:seqseqdble","seqseqdble",RuntimeTest::_tc_seqdble);
  71 TypeCode *RuntimeTest::_tc_seqseqobj = TypeCode::sequenceTc("eo:seqseqobj","seqseqobj",RuntimeTest::_tc_seqobj);
  72
  73 list<TypeCodeObjref *> RuntimeTest::_ltc;
  74 TypeCode *RuntimeTest::_tc_C;
  75 TypeCode *RuntimeTest::_tc_seqC;
  76
  77 map<string, Node*> RuntimeTest::_nodeMap;
  78 map<string, Bloc*> RuntimeTest::_blocMap;
  79 int RuntimeTest::_inode = 0;
  80 int RuntimeTest::_ibloc = 0;
  81 Runtime *RuntimeTest::_myRuntime = 0;
  82 bool RuntimeTest::endTests = false;
  83
  84 RuntimeForTest::RuntimeForTest()
  85 : RuntimeSALOME(UsePython+UseCorba+UseXml+UseCpp+UseSalome, 0, nullptr)
  86 {
  87 }
  88
  89 RuntimeForTest::~RuntimeForTest()
  90 {
  91 }
  92
  93 std::vector< std::pair<std::string,int> >
  94 RuntimeForTest::getCatalogOfComputeNodes() const
  95 {
  96   std::vector< std::pair<std::string,int> > result(1);
  97   std::pair<std::string,int> localhost;
  98   localhost.first = "localhost";
  99   localhost.second = 8;
 100   result[0] = localhost;
 101   return result;
 102 }
 103
 104 void RuntimeForTest::setRuntime()
 105 {
 106   if (! Runtime::_singleton)
 107     Runtime::_singleton = new RuntimeForTest;
 108 }
 109
 110 void RuntimeTest::setUp()
 111 {
 112   if (_ltc.size() == 0)
 113     {
 114       _ltc.push_back((TypeCodeObjref *)_tc_obj);
 115       _tc_C         = TypeCode::interfaceTc("IDL:eo/C:1.0","C",_ltc);
 116       _tc_seqC      = TypeCode::sequenceTc("eo:seqC","seqC",_tc_C);
 117     }
 118 }
 119
 120
 121 #define cRef(x) cerr << "_tc" << #x << " : " << _tc ## x->getRefCnt() << endl
 122
 123 void RuntimeTest::tearDown()
 124 {
 125 }
 126
 127
 128 void RuntimeTest::initRuntimeTypeCode()
 129 {
 130   // --- init runtime
 131   std::cerr << std::endl;
 132   RuntimeForTest::setRuntime();
 133   _myRuntime = getRuntime();
 134
 135   // --- init typecodes
 136
 137   DEBTRACE( " " << _tc->id() << " " << _tc->name() );
 138   DEBTRACE("int is a int: ");                CPPUNIT_ASSERT( _tc_int->isA(_tc_int));
 139   DEBTRACE("seqdble is not a seqlong: ");    CPPUNIT_ASSERT(!_tc_seqdble->isA(_tc_seqlong));
 140   DEBTRACE("seqdble is a seqdble: ");        CPPUNIT_ASSERT( _tc_seqdble->isA(_tc_seqdble));
 141   DEBTRACE("seqlong is not a seqdble: ");    CPPUNIT_ASSERT(!_tc_seqlong->isA(_tc_seqdble));
 142   DEBTRACE("C is a Obj: ");                  CPPUNIT_ASSERT( _tc_C->isA(_tc_obj));
 143   DEBTRACE("Obj is not a C: " );             CPPUNIT_ASSERT(!_tc_obj->isA(_tc_C));
 144   DEBTRACE("seqC is a seqObj: ");            CPPUNIT_ASSERT( _tc_seqC->isA(_tc_seqobj));
 145   DEBTRACE( "seqObj is not a seqC: ");       CPPUNIT_ASSERT(!_tc_seqobj->isA(_tc_seqC));
 146 }
 147
 148 void RuntimeTest::createPythonNodes()
 149 {
 150   // --- Nodes 0 a 4 : Python
 151
 152   for (int i=0; i<5; i++)
 153     {
 154       ostringstream ss;
 155       ss << "Node_" << _inode++;
 156       string s = ss.str();
 157       ElementaryNode* node = _myRuntime->createScriptNode("",s);
 158       _nodeMap[s] = node;
 159       InputPort  *i1  = node->edAddInputPort("id1",  _tc_double);
 160       InputPort  *i2  = node->edAddInputPort("ii2",  _tc_int);
 161       InputPort  *i3  = node->edAddInputPort("is3",  _tc_string);
 162       InputPort  *i4  = node->edAddInputPort("io4",  _tc_obj);
 163       InputPort  *i5  = node->edAddInputPort("isd5", _tc_seqdble);
 164       InputPort  *i6  = node->edAddInputPort("isl6", _tc_seqlong);
 165       InputPort  *i7  = node->edAddInputPort("iso7", _tc_seqobj);
 166       InputPort  *i8  = node->edAddInputPort("issd8",_tc_seqseqdble);
 167       InputPort  *i9  = node->edAddInputPort("isso9",_tc_seqseqobj);
 168       InputPort  *i10 = node->edAddInputPort("iC10", _tc_C);
 169       InputPort  *i11 = node->edAddInputPort("isC11",_tc_seqC);
 170
 171       OutputPort  *o1  = node->edAddOutputPort("od1",  _tc_double);
 172       OutputPort  *o2  = node->edAddOutputPort("oi2",  _tc_int);
 173       OutputPort  *o3  = node->edAddOutputPort("os3",  _tc_string);
 174       OutputPort  *o4  = node->edAddOutputPort("oo4",  _tc_obj);
 175       OutputPort  *o5  = node->edAddOutputPort("osd5", _tc_seqdble);
 176       OutputPort  *o6  = node->edAddOutputPort("osl6", _tc_seqlong);
 177       OutputPort  *o7  = node->edAddOutputPort("oso7", _tc_seqobj);
 178       OutputPort  *o8  = node->edAddOutputPort("ossd8",_tc_seqseqdble);
 179       OutputPort  *o9  = node->edAddOutputPort("osso9",_tc_seqseqobj);
 180       OutputPort  *o10 = node->edAddOutputPort("oC10", _tc_C);
 181       OutputPort  *o11 = node->edAddOutputPort("osC11",_tc_seqC);
 182       CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
 183       CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),11);
 184       CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),11);
 185       CPPUNIT_ASSERT_EQUAL(node->getInPortName(i10),string("iC10"));
 186       CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o10),string("oC10"));
 187       CPPUNIT_ASSERT_EQUAL(node->getInputPort("iC10"),i10);
 188       CPPUNIT_ASSERT_EQUAL(node->getOutputPort("oC10"),o10);
 189     }
 190 }
 191
 192
 193 void RuntimeTest::createCORBANodes()
 194 {
 195   // --- Nodes 5 a 9 : CORBA
 196
 197   for (int i=5; i<10; i++)
 198     {
 199       ostringstream ss;
 200       ss << "Node_" << _inode++;
 201       string s = ss.str();
 202       ElementaryNode* node = _myRuntime->createRefNode("",s);
 203       _nodeMap[s] = node;
 204       InputPort  *i1  = node->edAddInputPort("id1",  _tc_double);
 205       InputPort  *i2  = node->edAddInputPort("ii2",  _tc_int);
 206       InputPort  *i3  = node->edAddInputPort("is3",  _tc_string);
 207       InputPort  *i4  = node->edAddInputPort("io4",  _tc_obj);
 208       InputPort  *i5  = node->edAddInputPort("isd5", _tc_seqdble);
 209       InputPort  *i6  = node->edAddInputPort("isl6", _tc_seqlong);
 210       InputPort  *i7  = node->edAddInputPort("iso7", _tc_seqobj);
 211       InputPort  *i8  = node->edAddInputPort("issd8",_tc_seqseqdble);
 212       InputPort  *i9  = node->edAddInputPort("isso9",_tc_seqseqobj);
 213       InputPort  *i10 = node->edAddInputPort("iC10", _tc_C);
 214       InputPort  *i11 = node->edAddInputPort("isC11",_tc_seqC);
 215
 216       OutputPort  *o1  = node->edAddOutputPort("od1",  _tc_double);
 217       OutputPort  *o2  = node->edAddOutputPort("oi2",  _tc_int);
 218       OutputPort  *o3  = node->edAddOutputPort("os3",  _tc_string);
 219       OutputPort  *o4  = node->edAddOutputPort("oo4",  _tc_obj);
 220       OutputPort  *o5  = node->edAddOutputPort("osd5", _tc_seqdble);
 221       OutputPort  *o6  = node->edAddOutputPort("osl6", _tc_seqlong);
 222       OutputPort  *o7  = node->edAddOutputPort("oso7", _tc_seqobj);
 223       OutputPort  *o8  = node->edAddOutputPort("ossd8",_tc_seqseqdble);
 224       OutputPort  *o9  = node->edAddOutputPort("osso9",_tc_seqseqobj);
 225       OutputPort  *o10 = node->edAddOutputPort("oC10", _tc_C);
 226       OutputPort  *o11 = node->edAddOutputPort("osC11",_tc_seqC);
 227       CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("CORBA"));
 228       CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),11);
 229       CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),11);
 230       CPPUNIT_ASSERT_EQUAL(node->getInPortName(i10),string("iC10"));
 231       CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o10),string("oC10"));
 232       CPPUNIT_ASSERT_EQUAL(node->getInputPort("iC10"),i10);
 233       CPPUNIT_ASSERT_EQUAL(node->getOutputPort("oC10"),o10);
 234     }
 235 }
 236
 237
 238 void RuntimeTest::createBloc()
 239 {
 240   DEBTRACE(" --- create bloc, add two nodes, check constituants" );
 241
 242   // --- Bloc_0 with Node_0 and Node_1
 243   {
 244     ostringstream ss;
 245     ss << "Bloc_" << _ibloc++;
 246     string s = ss.str();
 247     Bloc* bloc = new Bloc(s);
 248     _nodeMap[s] = bloc;
 249     _blocMap[s] = bloc;
 250     bloc->edAddChild(_nodeMap["Node_0"]);
 251     bloc->edAddChild(_nodeMap["Node_1"]);
 252     {
 253       list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
 254       CPPUNIT_ASSERT(setelem.size() == 2);
 255     }
 256   }
 257
 258   // --- Bloc_1 with Node_2
 259   {
 260     ostringstream ss;
 261     ss << "Bloc_" << _ibloc++;
 262     string s = ss.str();
 263     Bloc* bloc = new Bloc(s);
 264     _nodeMap[s] = bloc;
 265     _blocMap[s] = bloc;
 266     bloc->edAddChild(_nodeMap["Node_2"]);
 267   }
 268
 269   DEBTRACE(" --- add a node already used in the bloc does nothing (return false)" );
 270   CPPUNIT_ASSERT( ! _blocMap["Bloc_0"]->edAddChild(_nodeMap["Node_1"]));
 271
 272   DEBTRACE(" --- add a node already used elsewhere raises exception " );
 273   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_1"]->edAddChild(_nodeMap["Node_1"]),
 274                        YACS::Exception);
 275 }
 276
 277
 278 void RuntimeTest::createRecursiveBlocs()
 279 {
 280   DEBTRACE(" --- recursive blocs, check constituants" );
 281
 282   // --- Bloc_2 with Bloc_0, Bloc_1 and Node_3
 283   {
 284     ostringstream ss;
 285     ss << "Bloc_" << _ibloc++;
 286     string s = ss.str();
 287     Bloc* bloc = new Bloc(s);
 288     _nodeMap[s] = bloc;
 289     _blocMap[s] = bloc;
 290     bloc->edAddChild(_nodeMap["Bloc_0"]);  // 2 elementary nodes
 291     bloc->edAddChild(_nodeMap["Bloc_1"]);  // 1 elementary node
 292     bloc->edAddChild(_nodeMap["Node_3"]);  // 1 elementary node
 293   }
 294
 295   {
 296     list<ElementaryNode *> setelem = _blocMap["Bloc_2"]->getRecursiveConstituents();
 297     CPPUNIT_ASSERT(setelem.size() == 4);
 298     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 299       {
 300         DEBTRACE("     elem name = " << (*it)->getName());
 301       }
 302   }
 303 }
 304
 305
 306 void RuntimeTest::createDataLinks()
 307 {
 308   DEBTRACE(" --- create and delete data links" );
 309
 310   CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 311   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_0"]->edAddLink(_nodeMap["Node_0"]->getOutputPort("od1"),
 312                                                      _nodeMap["Node_1"]->getInputPort("is3")),
 313                        YACS::ENGINE::ConversionException);
 314   CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 315
 316   _blocMap["Bloc_0"]->edAddLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
 317                                 _nodeMap["Node_1"]->getInputPort("ii2"));
 318   CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 319
 320   _blocMap["Bloc_0"]->edRemoveLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
 321                                    _nodeMap["Node_1"]->getInputPort("ii2"));
 322   CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
 323 }
 324
 325
 326 void RuntimeTest::createPythonNodesWithScript()
 327 {
 328   DEBTRACE(" --- create python nodes with scripts" );
 329
 330   // --- Node 10 : Python
 331
 332   {
 333     ostringstream ss;
 334     ss << "Node_" << _inode++;
 335     string s = ss.str();
 336     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 337     _nodeMap[s] = node;
 338     ((InlineNode*) node)->setScript("a=a+1\n");
 339     InputPort  *i1  = node->edAddInputPort("a",  _tc_double);
 340     OutputPort *o1  = node->edAddOutputPort("a", _tc_double);
 341     CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
 342     CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),1);
 343     CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
 344   }
 345
 346   // --- Node 11 : Python
 347
 348   {
 349     ostringstream ss;
 350     ss << "Node_" << _inode++;
 351     string s = ss.str();
 352     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 353     _nodeMap[s] = node;
 354     ((InlineNode*) node)->setScript("a=b+1\n"
 355                                      "c=2*a\n"
 356                                      "i=10\n"
 357                                      "s='aaaaaaa'\n"
 358                                      "seqdble=[1.5,2.4]\n"
 359                                      "lngvec=[1,2]\n"
 360                                      "dblevecvec=[[1.5,2.4],[6.7,7.8]]\n"
 361                                      );
 362     InputPort  *i1  = node->edAddInputPort("b",            _tc_double);
 363     OutputPort *o1  = node->edAddOutputPort("c",           _tc_double);
 364     OutputPort *o2  = node->edAddOutputPort("i",           _tc_int);
 365     OutputPort *o3  = node->edAddOutputPort("s",           _tc_string);
 366     OutputPort *o4  = node->edAddOutputPort("seqdble",     _tc_seqdble);
 367     OutputPort *o5  = node->edAddOutputPort("dblevecvec",  _tc_seqseqdble);
 368     OutputPort *o6  = node->edAddOutputPort("lngvec",      _tc_seqlong);
 369   }
 370
 371   // --- Node 12 : Python
 372
 373   {
 374     ostringstream ss;
 375     ss << "Node_" << _inode++;
 376     string s = ss.str();
 377     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 378     _nodeMap[s] = node;
 379     ((InlineNode*) node)->setScript("a=dble+1\n"
 380                                      "dble=2*a\n"
 381                                      );
 382     InputPort  *i1  = node->edAddInputPort("dble",  _tc_double);
 383     OutputPort *o1  = node->edAddOutputPort("dble", _tc_double);
 384   }
 385
 386   // --- Node 13 : Python
 387
 388   {
 389     ostringstream ss;
 390     ss << "Node_" << _inode++;
 391     string s = ss.str();
 392     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 393     _nodeMap[s] = node;
 394     ((InlineNode*) node)->setScript("print('node 13')\n"
 395                                      "import eo\n"
 396                                      "print(ob)\n"
 397                                      "o=ob._narrow(eo.Obj)\n"
 398                                      "print(o)\n"
 399                                      "print(o.echoLong(13))\n"
 400                                      "a=dble+1\n"
 401                                      "dble=2*a\n"
 402                                      "print(lng)\n"
 403                                      "print('++++++++',s,'+++++++++++++')\n"
 404                                      "ob=o\n"
 405                                      "seqstr=['aaa','bbb']\n"
 406                                      "seqobj=[o,o,o,o]\n"
 407                                      "seqseqobj=[[o,o],[o,o]]\n"
 408                                      );
 409
 410     InputPort  *i1  = node->edAddInputPort("dble",  _tc_double);
 411     InputPort  *i2  = node->edAddInputPort("lng",   _tc_int);
 412     InputPort  *i3  = node->edAddInputPort("s",     _tc_string);
 413     InputPort  *i4  = node->edAddInputPort("ob",    _tc_obj);
 414     OutputPort *o1  = node->edAddOutputPort("dble",       _tc_double);
 415     OutputPort *o2  = node->edAddOutputPort("s",          _tc_string);
 416     OutputPort *o3  = node->edAddOutputPort("lng",        _tc_int);
 417     OutputPort *o4  = node->edAddOutputPort("ob",         _tc_obj);
 418     OutputPort *o5  = node->edAddOutputPort("seqstr",     _tc_seqstr);
 419     OutputPort *o6  = node->edAddOutputPort("seqobj",     _tc_seqobj);
 420     OutputPort *o7  = node->edAddOutputPort("seqseqobj",  _tc_seqseqobj);
 421     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i1)->getPyObj(), Py_None);
 422     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i2)->getPyObj(), Py_None);
 423     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i3)->getPyObj(), Py_None);
 424     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i4)->getPyObj(), Py_None);
 425     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o1)->get(), Py_None);
 426     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o2)->get(), Py_None);
 427     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o3)->get(), Py_None);
 428     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o4)->get(), Py_None);
 429     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o5)->get(), Py_None);
 430     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o6)->get(), Py_None);
 431     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o7)->get(), Py_None);
 432   }
 433
 434   // --- Node 14 : Python
 435
 436   {
 437     ostringstream ss;
 438     ss << "Node_" << _inode++;
 439     string s = ss.str();
 440     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 441     _nodeMap[s] = node;
 442     ((InlineNode*) node)->setScript("print(li)\n"
 443                                      "print('lili=',lili)\n"
 444                                      "print('lstr=',lstr)\n"
 445                                      "print('lobj=',lobj)\n"
 446                                      "print('llobj=',llobj)\n"
 447                                      "print('objc=',objc)\n"
 448                                      "li=2*li\n"
 449                                      );
 450     InputPort  *i1  = node->edAddInputPort("li",    _tc_seqdble);
 451     InputPort  *i2  = node->edAddInputPort("lili",  _tc_seqseqdble);
 452     InputPort  *i3  = node->edAddInputPort("lstr",  _tc_seqstr);
 453     InputPort  *i4  = node->edAddInputPort("lobj",  _tc_seqobj);
 454     InputPort  *i5  = node->edAddInputPort("llobj", _tc_seqseqobj);
 455     InputPort  *i6  = node->edAddInputPort("objc",  _tc_C);
 456     OutputPort *o1  = node->edAddOutputPort("li",   _tc_seqdble);
 457     OutputPort *o2  = node->edAddOutputPort("objc", _tc_C);
 458     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i1)->getPyObj(), Py_None);
 459     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i2)->getPyObj(), Py_None);
 460     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i3)->getPyObj(), Py_None);
 461     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i4)->getPyObj(), Py_None);
 462     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i5)->getPyObj(), Py_None);
 463     CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i6)->getPyObj(), Py_None);
 464     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o1)->get(), Py_None);
 465     CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o2)->get(), Py_None);
 466   }
 467
 468   // --- Node 15 : Python
 469
 470   {
 471     ostringstream ss;
 472     ss << "Node_" << _inode++;
 473     string s = ss.str();
 474     ElementaryNode* node = _myRuntime->createScriptNode("",s);
 475     _nodeMap[s] = node;
 476     ((InlineNode*) node)->setScript("print(li)\n"
 477                                      "li=[2*e for e in li]\n"
 478                                      "print('obj=',obj)\n"
 479                                      "print(li)\n"
 480                                      "print(lngvec)\n"
 481                                      "print(dblevec)\n"
 482                                      );
 483     InputPort  *i1  = node->edAddInputPort("li",      _tc_seqdble);
 484     InputPort  *i2  = node->edAddInputPort("obj",     _tc_obj);
 485     InputPort  *i3  = node->edAddInputPort("lngvec",  _tc_seqlong);
 486     InputPort  *i4  = node->edAddInputPort("dblevec", _tc_seqdble);
 487     OutputPort *o1  = node->edAddOutputPort("li",     _tc_seqdble);
 488     CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
 489     CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),4);
 490     CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
 491   }
 492 }
 493
 494 void RuntimeTest::createCORBANodesWithMethod()
 495 {
 496   DEBTRACE(" --- create CORBA nodes" );
 497
 498   // --- Node 16 : CORBA
 499
 500   {
 501     ostringstream ss;
 502     ss << "Node_" << _inode++;
 503     string s = ss.str();
 504     ElementaryNode* node = _myRuntime->createRefNode("",s);
 505     _nodeMap[s] = node;
 506     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 507     ((ServiceNode *) node)->setMethod("echoDouble");
 508     InputPort  *i1  = node->edAddInputPort("a",  _tc_double);
 509     OutputPort *o1  = node->edAddOutputPort("c", _tc_double);
 510     CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("CORBA"));
 511     CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),1);
 512     CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
 513     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 514     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 515   }
 516
 517   // --- Node 17 - 18 : CORBA
 518
 519   for (int i =0; i <2; i++)
 520     {
 521       ostringstream ss;
 522       ss << "Node_" << _inode++;
 523       string s = ss.str();
 524       ElementaryNode* node = _myRuntime->createRefNode("",s);
 525       _nodeMap[s] = node;
 526       ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 527       ((ServiceNode *) node)->setMethod("echoDouble");
 528       InputPort  *i1  = node->edAddInputPort("b",  _tc_double);
 529       OutputPort *o1  = node->edAddOutputPort("c", _tc_double);
 530     }
 531
 532   // --- Node 19 : CORBA
 533
 534   {
 535     ostringstream ss;
 536     ss << "Node_" << _inode++;
 537     string s = ss.str();
 538     ElementaryNode* node = _myRuntime->createRefNode("",s);
 539     _nodeMap[s] = node;
 540     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 541     ((ServiceNode *) node)->setMethod("createObj");
 542     InputPort  *i1  = node->edAddInputPort("long",  _tc_int);
 543     OutputPort *o1  = node->edAddOutputPort("obj",  _tc_obj);
 544     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 545     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 546   }
 547
 548   // --- Node 20, 21, 22 : CORBA
 549
 550   for (int i =0; i <3; i++)
 551     {
 552       ostringstream ss;
 553       ss << "Node_" << _inode++;
 554       string s = ss.str();
 555       ElementaryNode* node = _myRuntime->createRefNode("",s);
 556       _nodeMap[s] = node;
 557       ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 558       ((ServiceNode *) node)->setMethod("echoAll");
 559       InputPort  *i1  = node->edAddInputPort("double",  _tc_double);
 560       InputPort  *i2  = node->edAddInputPort("long",    _tc_int);
 561       InputPort  *i3  = node->edAddInputPort("str",     _tc_string);
 562       InputPort  *i4  = node->edAddInputPort("obj",     _tc_obj);
 563       OutputPort *o1  = node->edAddOutputPort("double", _tc_double);
 564       OutputPort *o2  = node->edAddOutputPort("long",   _tc_int);
 565       OutputPort *o3  = node->edAddOutputPort("str",    _tc_string);
 566       OutputPort *o4  = node->edAddOutputPort("obj",    _tc_obj);
 567       CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i3)->getAny()->type()->kind(),CORBA::tk_null);
 568       CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i4)->getAny()->type()->kind(),CORBA::tk_null);
 569       CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o3)->getAny()->type()->kind(),CORBA::tk_null);
 570       CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o4)->getAny()->type()->kind(),CORBA::tk_null);
 571     }
 572
 573   // --- Node 23 a 26 : CORBA
 574
 575   for (int i =0; i <4; i++)
 576     {
 577       ostringstream ss;
 578       ss << "Node_" << _inode++;
 579       string s = ss.str();
 580       ElementaryNode* node = _myRuntime->createRefNode("",s);
 581       _nodeMap[s] = node;
 582       ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 583       ((ServiceNode *) node)->setMethod("echoDoubleVec");
 584       InputPort  *i1  = node->edAddInputPort("dblevec",  _tc_seqdble);
 585       OutputPort *o1  = node->edAddOutputPort("dblevec", _tc_seqdble);
 586       CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 587       CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 588     }
 589
 590   // --- Node 27 : CORBA
 591
 592   {
 593     ostringstream ss;
 594     ss << "Node_" << _inode++;
 595     string s = ss.str();
 596     ElementaryNode* node = _myRuntime->createRefNode("",s);
 597     _nodeMap[s] = node;
 598     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 599     ((ServiceNode *) node)->setMethod("echoStrVec");
 600     InputPort  *i1  = node->edAddInputPort("strvec",  _tc_seqstr);
 601     OutputPort *o1  = node->edAddOutputPort("strvec", _tc_seqstr);
 602     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 603     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 604   }
 605
 606   // --- Node 28 : CORBA
 607
 608   {
 609     ostringstream ss;
 610     ss << "Node_" << _inode++;
 611     string s = ss.str();
 612     ElementaryNode* node = _myRuntime->createRefNode("",s);
 613     _nodeMap[s] = node;
 614     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 615     ((ServiceNode *) node)->setMethod("echoObjectVec");
 616     InputPort  *i1  = node->edAddInputPort("objvec",  _tc_seqobj);
 617     OutputPort *o1  = node->edAddOutputPort("objvec", _tc_seqobj);
 618     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 619     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 620   }
 621
 622   // --- Node 29 : CORBA
 623
 624   {
 625     ostringstream ss;
 626     ss << "Node_" << _inode++;
 627     string s = ss.str();
 628     ElementaryNode* node = _myRuntime->createRefNode("",s);
 629     _nodeMap[s] = node;
 630     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 631     ((ServiceNode *) node)->setMethod("echoDoubleVecVec");
 632     InputPort  *i1  = node->edAddInputPort("dblevecvec",  _tc_seqseqdble);
 633     OutputPort *o1  = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
 634     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 635     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 636   }
 637
 638   // --- Node 30 : CORBA
 639
 640   {
 641     ostringstream ss;
 642     ss << "Node_" << _inode++;
 643     string s = ss.str();
 644     ElementaryNode* node = _myRuntime->createRefNode("",s);
 645     _nodeMap[s] = node;
 646     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 647     ((ServiceNode *) node)->setMethod("echoObjectVecVec");
 648     InputPort  *i1  = node->edAddInputPort("objvecvec",  _tc_seqseqobj);
 649     OutputPort *o1  = node->edAddOutputPort("objvecvec", _tc_seqseqobj);
 650     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 651     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 652   }
 653
 654   // --- Node 31 : CORBA
 655
 656   {
 657     ostringstream ss;
 658     ss << "Node_" << _inode++;
 659     string s = ss.str();
 660     ElementaryNode* node = _myRuntime->createRefNode("",s);
 661     _nodeMap[s] = node;
 662     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 663     ((ServiceNode *) node)->setMethod("echoIntVec");
 664     InputPort  *i1  = node->edAddInputPort("lngvec",  _tc_seqlong);
 665     OutputPort *o1  = node->edAddOutputPort("lngvec", _tc_seqlong);
 666     CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
 667     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 668   }
 669
 670   // --- Node 32 : CORBA
 671
 672   {
 673     ostringstream ss;
 674     ss << "Node_" << _inode++;
 675     string s = ss.str();
 676     ElementaryNode* node = _myRuntime->createRefNode("",s);
 677     _nodeMap[s] = node;
 678     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 679     ((ServiceNode *) node)->setMethod("createC");
 680     OutputPort *o1  = node->edAddOutputPort("objc", _tc_C);
 681     CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
 682   }
 683
 684   // --- Node 33 : CORBA
 685
 686   {
 687     ostringstream ss;
 688     ss << "Node_" << _inode++;
 689     string s = ss.str();
 690     ElementaryNode* node = _myRuntime->createRefNode("",s);
 691     _nodeMap[s] = node;
 692     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 693     ((ServiceNode *) node)->setMethod("echoDouble");
 694     InputPort  *i1  = node->edAddInputPort("dble",  _tc_double);
 695     OutputPort *o1  = node->edAddOutputPort("dble", _tc_double);
 696   }
 697
 698   // --- Node 34 : CORBA
 699
 700   {
 701     ostringstream ss;
 702     ss << "Node_" << _inode++;
 703     string s = ss.str();
 704     ElementaryNode* node = _myRuntime->createRefNode("",s);
 705     _nodeMap[s] = node;
 706     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 707     ((ServiceNode *) node)->setMethod("echoDoubleVec");
 708     InputPort  *i1  = node->edAddInputPort("dblevec",  _tc_seqdble);
 709     OutputPort *o1  = node->edAddOutputPort("dblevec", _tc_seqdble);
 710   }
 711
 712   // --- Node 35 : CORBA
 713
 714   {
 715     ostringstream ss;
 716     ss << "Node_" << _inode++;
 717     string s = ss.str();
 718     ElementaryNode* node = _myRuntime->createRefNode("",s);
 719     _nodeMap[s] = node;
 720     ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
 721     ((ServiceNode *) node)->setMethod("echoDoubleVecVec");
 722     InputPort  *i1  = node->edAddInputPort("dblevecvec",  _tc_seqseqdble);
 723     OutputPort *o1  = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
 724   }
 725 }
 726
 727
 728 void RuntimeTest::createXMLNodes()
 729 {
 730   DEBTRACE(" --- create XML nodes" );
 731
 732   // --- Node 36 : XML
 733
 734   {
 735     ostringstream ss;
 736     ss << "Node_" << _inode++;
 737     string s = ss.str();
 738     ElementaryNode* node = _myRuntime->createRefNode("xmlsh",s);
 739     _nodeMap[s] = node;
 740     ((ServiceNode *) node)->setRef("./xmlrun.sh");
 741     ((ServiceNode *) node)->setMethod("echo");
 742     InputPort  *i1  = node->edAddInputPort("dble",  _tc_double);
 743     InputPort  *i2  = node->edAddInputPort("dblevec",  _tc_seqdble);
 744     InputPort  *i3  = node->edAddInputPort("dblevecvec",  _tc_seqseqdble);
 745     OutputPort *o1  = node->edAddOutputPort("dble", _tc_double);
 746     OutputPort *o2  = node->edAddOutputPort("dblevec", _tc_seqdble);
 747     OutputPort *o3  = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
 748     CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("XML"));
 749     CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),3);
 750     CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),3);
 751   }
 752 }
 753
 754
 755 void RuntimeTest::createBloc2()
 756 {
 757   DEBTRACE(" --- create Bloc with all nodes" );
 758
 759   // --- Bloc_3 with Node_10 and following
 760
 761   {
 762     ostringstream ss;
 763     ss << "Bloc_" << _ibloc++;
 764     string s = ss.str();
 765     Bloc* bloc = new Bloc(s);
 766     _nodeMap[s] = bloc;
 767     _blocMap[s] = bloc;
 768     for (int i=10; i<_inode; i++)
 769       {
 770         ostringstream ssn;
 771         ssn << "Node_" << i;
 772         string sn = ssn.str();
 773         cerr << sn << endl;
 774         bloc->edAddChild(_nodeMap[sn]);
 775       }
 776     {
 777       list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
 778       CPPUNIT_ASSERT(setelem.size() == _inode - 10);
 779     }
 780   }
 781   set<InputPort *> unitialized =  _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
 782   DEBTRACE(unitialized.size());
 783   CPPUNIT_ASSERT(! _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
 784 }
 785
 786
 787 void RuntimeTest::createDataLinksPythonPython()
 788 {
 789   DEBTRACE(" --- create data links, python to python" );
 790
 791
 792   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
 793                                 _nodeMap["Node_11"]->getInputPort("b"));
 794
 795
 796   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
 797                                 _nodeMap["Node_12"]->getInputPort("dble"));
 798
 799   // --- Python sequence<double> -> Python sequence<double>
 800   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_14"]->getOutputPort("li"),
 801                                 _nodeMap["Node_15"]->getInputPort("li"));
 802
 803   // --- Python obj C (derived from Obj) -> Python obj Obj : accepted
 804   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_14"]->getOutputPort("objc"),
 805                                 _nodeMap["Node_15"]->getInputPort("obj"));
 806
 807   // --- Python Obj -> Python C (derived from Obj) : forbidden
 808   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
 809                                                      _nodeMap["Node_14"]->getInputPort("objc")),
 810                        YACS::ENGINE::ConversionException);
 811
 812   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
 813                                                      _nodeMap["Node_12"]->getInputPort("dble")),
 814                        YACS::ENGINE::ConversionException);
 815
 816   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
 817                                                      _nodeMap["Node_12"]->getInputPort("dble")),
 818                        YACS::ENGINE::ConversionException);
 819 }
 820
 821
 822 void RuntimeTest::createDataLinksPythonCORBA()
 823 {
 824   DEBTRACE(" --- create data links, python to CORBA" );
 825
 826   // --- double->double
 827   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("c"),
 828                                 _nodeMap["Node_16"]->getInputPort("a"));
 829
 830   // --- int->int
 831   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("i"),
 832                                 _nodeMap["Node_19"]->getInputPort("long"));
 833
 834   // --- str->str
 835   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
 836                                 _nodeMap["Node_20"]->getInputPort("str"));
 837   cerr << "##### 3" << endl;
 838
 839   // --- seq<long> -> seq<double>
 840   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
 841                                 _nodeMap["Node_23"]->getInputPort("dblevec"));
 842
 843   // --- seq<long> -> seq<long>
 844   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
 845                                 _nodeMap["Node_31"]->getInputPort("lngvec"));
 846
 847   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
 848                                 _nodeMap["Node_22"]->getInputPort("obj"));
 849
 850   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
 851                                 _nodeMap["Node_26"]->getInputPort("dblevec"));
 852
 853   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
 854                                 _nodeMap["Node_27"]->getInputPort("strvec"));
 855
 856   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqobj"),
 857                                 _nodeMap["Node_28"]->getInputPort("objvec"));
 858
 859   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
 860                                 _nodeMap["Node_29"]->getInputPort("dblevecvec"));
 861
 862   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqseqobj"),
 863                                 _nodeMap["Node_30"]->getInputPort("objvecvec"));
 864
 865   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
 866                                                      _nodeMap["Node_27"]->getInputPort("strvec")),
 867                        YACS::ENGINE::ConversionException);
 868
 869   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
 870                                                      _nodeMap["Node_22"]->getInputPort("str")),
 871                        YACS::ENGINE::ConversionException);
 872
 873   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
 874                                                      _nodeMap["Node_22"]->getInputPort("str")),
 875                        YACS::ENGINE::ConversionException);
 876
 877   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("lng"),
 878                                                      _nodeMap["Node_22"]->getInputPort("str")),
 879                        YACS::ENGINE::ConversionException);
 880
 881   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
 882                                                      _nodeMap["Node_22"]->getInputPort("long")),
 883                        YACS::ENGINE::ConversionException);
 884
 885   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
 886                                                      _nodeMap["Node_24"]->getInputPort("dblevec")),
 887                        YACS::ENGINE::ConversionException);
 888
 889   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
 890                                                      _nodeMap["Node_24"]->getInputPort("dblevec")),
 891                        YACS::ENGINE::ConversionException);
 892
 893   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
 894                                                      _nodeMap["Node_24"]->getInputPort("dblevec")),
 895                        YACS::ENGINE::ConversionException);
 896 }
 897
 898
 899 void RuntimeTest::createDataLinksCORBACORBA()
 900 {
 901   DEBTRACE(" --- create data links, CORBA to CORBA" );
 902
 903   // double->double
 904   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
 905                                 _nodeMap["Node_17"]->getInputPort("b"));
 906
 907   // double->double
 908   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
 909                                 _nodeMap["Node_18"]->getInputPort("b"));
 910
 911   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
 912                                                      _nodeMap["Node_21"]->getInputPort("double")),
 913                        YACS::ENGINE::ConversionException);
 914
 915   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
 916                                                      _nodeMap["Node_31"]->getInputPort("lngvec")),
 917                        YACS::ENGINE::ConversionException);
 918
 919   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
 920                                                      _nodeMap["Node_27"]->getInputPort("strvec")),
 921                        YACS::ENGINE::ConversionException);
 922
 923   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
 924                                 _nodeMap["Node_20"]->getInputPort("obj"));
 925
 926   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_18"]->getOutputPort("c"),
 927                                 _nodeMap["Node_20"]->getInputPort("double"));
 928
 929   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
 930                                 _nodeMap["Node_21"]->getInputPort("double"));
 931
 932   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
 933                                 _nodeMap["Node_21"]->getInputPort("long"));
 934
 935   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
 936                                 _nodeMap["Node_21"]->getInputPort("str"));
 937
 938   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("obj"),
 939                                 _nodeMap["Node_21"]->getInputPort("obj"));
 940
 941   // Corba sequence<double> -> Corba sequence<double>
 942   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
 943                                 _nodeMap["Node_24"]->getInputPort("dblevec"));
 944
 945   // Corba sequence<double> -> Corba sequence<double>
 946   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
 947                                 _nodeMap["Node_25"]->getInputPort("dblevec"));
 948
 949   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
 950                                 _nodeMap["Node_22"]->getInputPort("double"));
 951
 952   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
 953                                 _nodeMap["Node_22"]->getInputPort("long"));
 954
 955   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
 956                                 _nodeMap["Node_22"]->getInputPort("str"));
 957 }
 958
 959
 960 void RuntimeTest::createDataLinksCORBAPython()
 961 {
 962   DEBTRACE(" --- create data links, CORBA to Python" );
 963
 964   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("double"),
 965                                                      _nodeMap["Node_13"]->getInputPort("lng")),
 966                        YACS::ENGINE::ConversionException);
 967
 968   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
 969                                                      _nodeMap["Node_13"]->getInputPort("s")),
 970                        YACS::ENGINE::ConversionException);
 971
 972
 973   // Corba C -> Python C (derived from Obj):OK
 974   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_32"]->getOutputPort("objc"),
 975                                 _nodeMap["Node_14"]->getInputPort("objc"));
 976
 977   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("double"),
 978                                 _nodeMap["Node_13"]->getInputPort("dble"));
 979
 980   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("long"),
 981                                 _nodeMap["Node_13"]->getInputPort("lng"));
 982
 983   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("str"),
 984                                 _nodeMap["Node_13"]->getInputPort("s"));
 985
 986   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("obj"),
 987                                 _nodeMap["Node_13"]->getInputPort("ob"));
 988
 989   // --- Corba sequence<double> -> Python sequence<double>
 990   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
 991                                 _nodeMap["Node_14"]->getInputPort("li"));
 992
 993   // --- Corba sequence<sequence<double>> -> Python sequence<sequence<double>>
 994   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_29"]->getOutputPort("dblevecvec"),
 995                                 _nodeMap["Node_14"]->getInputPort("lili"));
 996
 997   // --- Corba sequence<object> -> Python sequence<object>
 998   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_28"]->getOutputPort("objvec"),
 999                                 _nodeMap["Node_14"]->getInputPort("lobj"));
1000
1001   // --- Corba sequence<string> -> Python sequence<string>
1002   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
1003                                 _nodeMap["Node_14"]->getInputPort("lstr"));
1004
1005   // --- Corba sequence<object> -> Python sequence<object>
1006   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_30"]->getOutputPort("objvecvec"),
1007                                 _nodeMap["Node_14"]->getInputPort("llobj"));
1008
1009   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
1010                                 _nodeMap["Node_15"]->getInputPort("lngvec"));
1011
1012   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
1013                                 _nodeMap["Node_15"]->getInputPort("dblevec"));
1014 }
1015
1016
1017 void RuntimeTest::createDataLinksXML()
1018 {
1019   DEBTRACE(" --- create data links, xml nodes" );
1020
1021   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
1022                                                      _nodeMap["Node_36"]->getInputPort("dblevec")),
1023                        YACS::ENGINE::ConversionException);
1024
1025   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
1026                                                      _nodeMap["Node_36"]->getInputPort("dble")),
1027                        YACS::ENGINE::ConversionException);
1028
1029   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1030                                                      _nodeMap["Node_33"]->getInputPort("dble")),
1031                        YACS::ENGINE::ConversionException);
1032
1033   CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1034                                                      _nodeMap["Node_34"]->getInputPort("dblevec")),
1035                        YACS::ENGINE::ConversionException);
1036
1037   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
1038                                 _nodeMap["Node_36"]->getInputPort("dble"));
1039
1040   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
1041                                 _nodeMap["Node_36"]->getInputPort("dblevec"));
1042
1043   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_29"]->getOutputPort("dblevecvec"),
1044                                 _nodeMap["Node_36"]->getInputPort("dblevecvec"));
1045
1046   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1047                                 _nodeMap["Node_33"]->getInputPort("dble"));
1048
1049   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1050                                 _nodeMap["Node_34"]->getInputPort("dblevec"));
1051
1052   _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevecvec"),
1053                                 _nodeMap["Node_35"]->getInputPort("dblevecvec"));
1054 }
1055
1056
1057 void RuntimeTest::manualInitInputPort()
1058 {
1059   DEBTRACE(" --- InputPort initialization" );
1060
1061   {
1062     CPPUNIT_ASSERT(! _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
1063     set<InputPort *> unitialized =  _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
1064     DEBTRACE(unitialized.size());
1065     for (set<InputPort *>::const_iterator iter = unitialized.begin(); iter != unitialized.end(); iter++)
1066       {
1067         DEBTRACE(_blocMap["Bloc_3"]->getInPortName(*iter));
1068       }
1069   }
1070   _nodeMap["Node_10"]->getInputPort("a")->edInit(10.51);
1071
1072 //   CORBA::Any anyLong;
1073 //   anyLong <<= (CORBA::Long) 1;
1074   DEBTRACE("---");
1075   _nodeMap["Node_20"]->getInputPort("long")->edInit(1);
1076   DEBTRACE("---");
1077
1078   // --- manual set of a linked input port: no use under normal conditions
1079   //     (value will be replaced by output value before activation and read)
1080
1081   CORBA::Any aString;
1082   aString <<= (const char *)"texte";
1083   _nodeMap["Node_20"]->getInputPort("str")->put(&aString);
1084 //  _nodeMap["Node_20"]->getInputPort("str")->edInit("texte");
1085   DEBTRACE("---");
1086
1087   {
1088     set<InputPort *> unitialized =  _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
1089     DEBTRACE(unitialized.size());
1090     CPPUNIT_ASSERT( _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
1091   }
1092
1093   {
1094     double d=10.51;
1095     int l;
1096     PyObject *pyob;
1097     CORBA::Any *any;
1098     Any * a;
1099     DEBTRACE("Python input port double");
1100     InputPort* inport=_nodeMap["Node_10"]->getInputPort("a");
1101
1102     DEBTRACE("Initialize port with C++ double value");
1103     a = AtomAny::New(d);
1104     inport->edInit("Cpp",a);
1105     a->decrRef();
1106     pyob=((InputPyPort*)inport)->getPyObj();
1107     DEBTRACE(pyob->ob_refcnt);
1108     CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1109
1110     DEBTRACE("Initialize port with XML double value");
1111     inport->edInit("XML","<value><double>10.51</double></value>");
1112     pyob=((InputPyPort*)inport)->getPyObj();
1113     DEBTRACE(pyob->ob_refcnt);
1114     CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1115
1116     DEBTRACE("Initialize port with XML int value");
1117     inport->edInit("XML","<value><int>10</int></value>");
1118     pyob=((InputPyPort*)inport)->getPyObj();
1119     DEBTRACE(pyob->ob_refcnt);
1120     CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == 10.);
1121
1122     DEBTRACE("Initialize port with Python double value");
1123     PyGILState_STATE gstate = PyGILState_Ensure();
1124     inport->edInit("Python",PyFloat_FromDouble(d));
1125     PyGILState_Release(gstate);
1126     pyob=((InputPyPort*)inport)->getPyObj();
1127     DEBTRACE(pyob->ob_refcnt);
1128     CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1129
1130     DEBTRACE("Python input port seq<double>");
1131     inport=_nodeMap["Node_14"]->getInputPort("li");
1132     DEBTRACE("Initialize port with XML seq<double> value");
1133     inport->edInit("XML","<value><array><data>\
1134             <value><double>1.5</double></value>\
1135             <value><double>2.4</double></value>\
1136             </data></array></value>");
1137     pyob=((InputPyPort*)inport)->getPyObj();
1138     DEBTRACE(pyob->ob_refcnt);
1139
1140     DEBTRACE("Initialize port with XML seq<int> value");
1141     inport->edInit("XML","<value><array><data>\
1142             <value><int>15</int></value>\
1143             <value><int>24</int></value>\
1144             </data></array></value>");
1145     pyob=((InputPyPort*)inport)->getPyObj();
1146     DEBTRACE(pyob->ob_refcnt);
1147
1148     DEBTRACE("CORBA input port int");
1149     inport=_nodeMap["Node_20"]->getInputPort("long");
1150     DEBTRACE("Initialize port with XML int value");
1151     inport->edInit("XML","<value><int>10</int></value>");
1152     any=((InputCorbaPort*)inport)->getAny();
1153     CORBA::Long LL;
1154     *any >>= LL;
1155     l = LL;
1156     DEBTRACE("l = " << l);
1157     CPPUNIT_ASSERT(l == 10);
1158
1159     DEBTRACE("CORBA input port double");
1160     inport=_nodeMap["Node_17"]->getInputPort("b");
1161     DEBTRACE("Initialize port with XML double value");
1162     inport->edInit("XML","<value><double>10.51</double></value>");
1163     any=((InputCorbaPort*)inport)->getAny();
1164     *any >>= d;
1165     CPPUNIT_ASSERT_DOUBLES_EQUAL(10.51,d, 1e-12);
1166
1167     DEBTRACE("CORBA input port seq<double>");
1168     inport=_nodeMap["Node_24"]->getInputPort("dblevec");
1169     DEBTRACE("Initialize port with XML seq<double> value");
1170     inport->edInit("XML","<value><array><data>\
1171             <value><double>1.5</double></value>\
1172             <value><double>2.4</double></value>\
1173             </data></array></value>");
1174
1175   }
1176 }
1177
1178 void RuntimeTest::manualExecuteNoThread()
1179 {
1180   DEBTRACE(" --- execution Python Node_10" );
1181   ((ElementaryNode*)_nodeMap["Node_10"])->load();
1182   ((ElementaryNode*)_nodeMap["Node_10"])->execute();
1183   //  CPPUNIT_ASSERT_DOUBLES_EQUAL(10.51, (ElementaryNode*)_nodeMap["Node_10"])
1184   DEBTRACE(" --- execution Python Node_11" );
1185   ((ElementaryNode*)_nodeMap["Node_11"])->load();
1186   ((ElementaryNode*)_nodeMap["Node_11"])->execute();
1187
1188   DEBTRACE(" --- execution Python Node_12" );
1189   ((ElementaryNode*)_nodeMap["Node_12"])->load();
1190   ((ElementaryNode*)_nodeMap["Node_12"])->execute();
1191
1192   DEBTRACE(" --- execution CORBA Node_16" );
1193   ((ElementaryNode*)_nodeMap["Node_16"])->load();
1194   ((ElementaryNode*)_nodeMap["Node_16"])->execute();
1195
1196   DEBTRACE(" --- execution CORBA Node_17" );
1197   ((ElementaryNode*)_nodeMap["Node_17"])->load();
1198   ((ElementaryNode*)_nodeMap["Node_17"])->execute();
1199
1200   DEBTRACE(" --- execution CORBA Node_18" );
1201   ((ElementaryNode*)_nodeMap["Node_18"])->load();
1202   ((ElementaryNode*)_nodeMap["Node_18"])->execute();
1203
1204   DEBTRACE(" --- execution CORBA Node_19" );
1205   ((ElementaryNode*)_nodeMap["Node_19"])->load();
1206   ((ElementaryNode*)_nodeMap["Node_19"])->execute();
1207
1208   DEBTRACE(" --- execution CORBA Node_20" );
1209   ((ElementaryNode*)_nodeMap["Node_20"])->load();
1210   ((ElementaryNode*)_nodeMap["Node_20"])->execute();
1211
1212   DEBTRACE(" --- execution CORBA Node_21" );
1213   ((ElementaryNode*)_nodeMap["Node_21"])->load();
1214   ((ElementaryNode*)_nodeMap["Node_21"])->execute();
1215
1216   DEBTRACE(" --- execution CORBA Node_29" );
1217   ((ElementaryNode*)_nodeMap["Node_29"])->load();
1218   ((ElementaryNode*)_nodeMap["Node_29"])->execute();
1219
1220   DEBTRACE(" --- execution Python Node_13" );
1221   ((ElementaryNode*)_nodeMap["Node_13"])->load();
1222   ((ElementaryNode*)_nodeMap["Node_13"])->execute();
1223
1224   DEBTRACE(" --- execution CORBA Node_22" );
1225   ((ElementaryNode*)_nodeMap["Node_22"])->load();
1226   ((ElementaryNode*)_nodeMap["Node_22"])->execute();
1227
1228   DEBTRACE(" --- execution CORBA Node_23" );
1229   ((ElementaryNode*)_nodeMap["Node_23"])->load();
1230   ((ElementaryNode*)_nodeMap["Node_23"])->execute();
1231
1232   DEBTRACE(" --- execution CORBA Node_24" );
1233   ((ElementaryNode*)_nodeMap["Node_24"])->load();
1234   ((ElementaryNode*)_nodeMap["Node_24"])->execute();
1235
1236   DEBTRACE(" --- execution CORBA Node_27" );
1237   ((ElementaryNode*)_nodeMap["Node_27"])->load();
1238   ((ElementaryNode*)_nodeMap["Node_27"])->execute();
1239
1240   DEBTRACE(" --- execution CORBA Node_28" );
1241   ((ElementaryNode*)_nodeMap["Node_28"])->load();
1242   ((ElementaryNode*)_nodeMap["Node_28"])->execute();
1243
1244   DEBTRACE(" --- execution CORBA Node_30" );
1245   ((ElementaryNode*)_nodeMap["Node_30"])->load();
1246   ((ElementaryNode*)_nodeMap["Node_30"])->execute();
1247
1248   DEBTRACE(" --- execution CORBA Node_32" );
1249   ((ElementaryNode*)_nodeMap["Node_32"])->load();
1250   ((ElementaryNode*)_nodeMap["Node_32"])->execute();
1251
1252   DEBTRACE(" --- execution CORBA Node_26" );
1253   ((ElementaryNode*)_nodeMap["Node_26"])->load();
1254   ((ElementaryNode*)_nodeMap["Node_26"])->execute();
1255
1256   DEBTRACE(" --- execution CORBA Node_31" );
1257   ((ElementaryNode*)_nodeMap["Node_31"])->load();
1258   ((ElementaryNode*)_nodeMap["Node_31"])->execute();
1259
1260   DEBTRACE(" --- execution Python Node_14" );
1261   ((ElementaryNode*)_nodeMap["Node_14"])->load();
1262   ((ElementaryNode*)_nodeMap["Node_14"])->execute();
1263
1264   DEBTRACE(" --- execution Python Node_15" );
1265   ((ElementaryNode*)_nodeMap["Node_15"])->load();
1266   ((ElementaryNode*)_nodeMap["Node_15"])->execute();
1267
1268   std::cerr << __LINE__ << std::endl;
1269   DEBTRACE(" --- execution XML Node_36" );
1270   ((ElementaryNode*)_nodeMap["Node_36"])->load();
1271   ((ElementaryNode*)_nodeMap["Node_36"])->execute();
1272
1273   DEBTRACE(" --- execution CORBA Node_33" );
1274   ((ElementaryNode*)_nodeMap["Node_33"])->load();
1275   ((ElementaryNode*)_nodeMap["Node_33"])->execute();
1276
1277   DEBTRACE(" --- execution CORBA Node_34" );
1278   ((ElementaryNode*)_nodeMap["Node_34"])->load();
1279   ((ElementaryNode*)_nodeMap["Node_34"])->execute();
1280
1281   DEBTRACE(" --- execution CORBA Node_35" );
1282   ((ElementaryNode*)_nodeMap["Node_35"])->load();
1283   ((ElementaryNode*)_nodeMap["Node_35"])->execute();
1284
1285   DEBTRACE(" --- end of execution" );
1286 }
1287
1288
1289 void RuntimeTest::manualGetOutputs()
1290 {
1291   CORBA::Double l;
1292   CORBA::Any* x;
1293
1294   PyObject *ob=((OutputPyPort*)_nodeMap["Node_11"]->getOutputPort("c"))->get();
1295   DEBTRACE("ob refcnt: " << ob->ob_refcnt);
1296   std::cerr << "Output port Node_11.c: ";
1297   PyGILState_STATE gstate = PyGILState_Ensure();
1298   PyObject_Print(ob,stderr,Py_PRINT_RAW);
1299   PyGILState_Release(gstate);
1300   std::cerr << std::endl;
1301
1302   //   DEBTRACE("a: " << &a);
1303   //   DEBTRACE("a.value(): " << a.value());
1304
1305   x= ((InputCorbaPort*)_nodeMap["Node_16"]->getInputPort("a"))->getAny();
1306   DEBTRACE("CORBA Node_16 input a any: " << x);
1307   *x >>= l;
1308   DEBTRACE("CORBA Node_16 input a double: " << l);
1309
1310   *((InputCorbaPort*)_nodeMap["Node_17"]->getInputPort("b"))->getAny() >>= l;
1311   DEBTRACE("CORBA Node_17 input b double: " << l);
1312
1313   *((InputCorbaPort*)_nodeMap["Node_18"]->getInputPort("b"))->getAny() >>= l;
1314   DEBTRACE("CORBA Node_18 input a double: " << l);
1315
1316   *((OutputCorbaPort*)_nodeMap["Node_16"]->getOutputPort("c"))->getAny() >>= l;
1317   DEBTRACE("CORBA Node_16 output c double: " << l);
1318
1319   *((OutputCorbaPort*)_nodeMap["Node_17"]->getOutputPort("c"))->getAny() >>= l;
1320   DEBTRACE("CORBA Node_17 output c double: " << l);
1321
1322   *((OutputCorbaPort*)_nodeMap["Node_18"]->getOutputPort("c"))->getAny() >>= l;
1323   DEBTRACE("CORBA Node_18 output c double: " << l);
1324
1325   DEBTRACE(" --- fini" );
1326 }
1327
1328 void RuntimeTest::createCppNodes()
1329 {
1330
1331   string s = "Node_Cpp";
1332   ElementaryNode* node = _myRuntime->createCompoNode("Cpp",s);
1333   _nodeMap[s] = node;
1334   InputPort  *i1  = node->edAddInputPort("id1",  _tc_double);
1335   InputPort  *i2  = node->edAddInputPort("ii2",  _tc_int);
1336
1337   OutputPort  *o3  = node->edAddOutputPort("os3",  _tc_string);
1338
1339   CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Cpp"));
1340   CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),2);
1341   CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
1342   CPPUNIT_ASSERT_EQUAL(node->getInPortName(i1),string("id1"));
1343   CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o3),string("os3"));
1344
1345   CPPUNIT_ASSERT_EQUAL(node->getInputPort("id1"),i1);
1346   CPPUNIT_ASSERT_EQUAL(node->getOutputPort("os3"),o3);
1347
1348   delete node;
1349 }
1350
1351 void RuntimeTest::convertPorts()
1352 {
1353   const char *type[] = { "Cpp", "CORBA", "Python", "XML" };
1354   int itype, jtype, ntypes = sizeof(type)/sizeof(const char *);
1355
1356   string s0 = "Node_";
1357   CORBA::Any  cAny;
1358   PyObject  * pAny;
1359   Any       * vAny;
1360   std::string sAny;
1361
1362   for (itype=0; itype<ntypes-1; itype++)
1363     {
1364       string s = s0 + type[itype];
1365
1366       cerr << endl;
1367       DEBTRACE("Node " << type[itype] << " creation");
1368       ElementaryNode* node;
1369       switch (itype)
1370         {
1371         case 1:
1372           node = _myRuntime->createRefNode(type[itype],s);
1373           break;
1374         case 2:
1375           node = _myRuntime->createScriptNode(type[itype], s);
1376           break;
1377         case 3:
1378           node = _myRuntime->createRefNode("xmlsh",s);
1379           break;
1380         default:
1381           node = _myRuntime->createCompoNode(type[itype], s);
1382           break;
1383         }
1384       InputPort  *inport  = node->edAddInputPort("id1",  _tc_double);
1385       CPPUNIT_ASSERT(NULL != node);
1386       for (jtype=0; jtype < ntypes; jtype++)
1387         {
1388           double d0= itype * 10 + jtype, d1;
1389           InputPort* pwrap=_myRuntime->adapt(inport, type[jtype], _tc_double);
1390
1391           const void *v;
1392           switch (jtype)
1393             {
1394             case 0:
1395             case 4:
1396               v = vAny = AtomAny::New(d0);
1397               break;
1398             case 1:
1399               v = &cAny;
1400               cAny <<= (CORBA::Double) d0;
1401               break;
1402             case 2:
1403               v = pAny = PyFloat_FromDouble(d0);
1404               break;
1405             case 3:
1406               {
1407                 ostringstream os;
1408                 os << "<value><double>" << d0 << "</double></value>";
1409                 sAny = os.str();
1410                 v = sAny.c_str();
1411               }
1412               break;
1413             default:
1414               v = NULL;
1415               break;
1416             }
1417
1418             if ((itype == 2) && (jtype == 2))
1419               {
1420                 std::cerr << "s = " << s << endl;
1421               }
1422
1423             DEBTRACE("Put a " << type[jtype] << " double (" << d0 << ") in " << s);
1424             if (jtype == 2)
1425               {
1426                 PyGILState_STATE gstate = PyGILState_Ensure();
1427                 pwrap->put(v);
1428                 PyGILState_Release(gstate);
1429               }
1430             else
1431               pwrap->put(v);
1432             cerr << endl;
1433
1434             switch (itype)
1435               {
1436               case 0:
1437               case 4:
1438                 {
1439                   Any * a=((InputCppPort*)inport)->getCppObj();
1440                   CPPUNIT_ASSERT(a->getType()->isA(_tc_double));
1441                   d1 = a->getDoubleValue();
1442                 }
1443                 break;
1444               case 1:
1445                 {
1446                   CORBA::Any * a = ((InputCorbaPort*)inport)->getAny();
1447                   CPPUNIT_ASSERT(a->type()->equal(CORBA::_tc_double));
1448                   CORBA::Double d;
1449                   *a >>= d;
1450                   d1 = d;
1451                 }
1452                 break;
1453               case 2:
1454                 {
1455                   PyObject *a = ((InputPyPort*)inport)->getPyObj();
1456                   CPPUNIT_ASSERT(PyFloat_Check(a));
1457                   d1 = PyFloat_AsDouble(a);
1458                 }
1459                 break;
1460               case 3:
1461                 {
1462                   const char *a = ((InputXmlPort*)inport)->getXml();
1463                   const char *a1, *a2, *a3, *a_end;
1464                   a_end = a + strlen(a) - 1;
1465                   while (isspace(*a_end)) a_end--;
1466                   a1 = a;
1467                   a2 = a + strlen("<value><double>");
1468                   a3 = a_end - strlen("</double></value>") + 1;
1469                   CPPUNIT_ASSERT(!strncmp(a1, "<value><double>", strlen("<value><double>")));
1470                   CPPUNIT_ASSERT(!strncmp(a3, "</double></value>", strlen("</double></value>")));
1471                   char *err;
1472                   d1 = strtod(a2, &err);
1473                   CPPUNIT_ASSERT(err == a3);
1474                 }
1475                 break;
1476               }
1477
1478             CPPUNIT_ASSERT_DOUBLES_EQUAL(d0, d1, 1e-12);
1479
1480             switch (jtype)
1481               {
1482               case 0:
1483               case 4:
1484                 vAny->decrRef();
1485                 break;
1486               case 2:
1487                 Py_DECREF(pAny);
1488                 break;
1489               default:
1490                 break;
1491               }
1492           if (pwrap != inport) delete pwrap;
1493         }
1494       delete node;
1495     }
1496 }
1497
1498 void myTestRun(int nIn, int nOut, Any **In, Any **Out)
1499 {
1500   double x, y;
1501   cerr << "myTestRun nIn = " << nIn << endl;
1502   cerr << "myTestRun nOut = " << nOut << endl;
1503
1504   x = In[0]->getDoubleValue();
1505
1506   if (x >= 0.0)
1507     {
1508       y = sqrt(x);
1509       Out[0] = AtomAny::New(y);
1510     }
1511   else
1512     {
1513       throw YACS::Exception("myTestRun : input must be a positive or null real");
1514     }
1515 }
1516
1517
1518 void RuntimeTest::executeCppNode()
1519 {
1520   cerr << endl << endl;
1521
1522   Any *u, *v, *w;
1523   double du, dv, dw;
1524
1525   DEBTRACE("execute a CppNode with an internal C++ implementation")
1526   ServiceNode * node = _myRuntime->createCompoNode("Cpp", "test");
1527   ((CppNode *) node)->setFunc(myTestRun);
1528
1529   InputPort  *in  = node->edAddInputPort("in",  _tc_double);
1530   OutputPort  *out  = node->edAddOutputPort("out",  _tc_double);
1531   node->load();
1532
1533   dv = 4.5;
1534   v = AtomAny::New(dv);
1535   in->edInit("Cpp",v);
1536
1537   node->execute();
1538
1539   w = ((OutputCppPort *) out)->get();
1540   dw = w->getDoubleValue();
1541
1542   cerr << "sqrt(" << dv << ") = " << dw << endl;
1543   CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1544
1545   u = AtomAny::New((double) -3.5);
1546   in->edInit("Cpp",u);
1547   CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1548
1549   u->decrRef();
1550   v->decrRef();
1551
1552   delete node;
1553
1554   DEBTRACE("execute a CppNode with an external C++ implementation (in a dynamic library)");
1555
1556   node = _myRuntime->createCompoNode("Cpp", "test");
1557   CppComponent * C = new CppComponent("TestComponent");
1558   node->setComponent(C);
1559   C->decrRef();
1560   node->setMethod("f");
1561
1562   in  = node->edAddInputPort("in",  _tc_double);
1563   out  = node->edAddOutputPort("out",  _tc_double);
1564   node->load();
1565
1566   dv = 4.5;
1567   v = AtomAny::New(dv);
1568   in->edInit("Cpp",v);
1569
1570   node->execute();
1571
1572   w = ((OutputCppPort *) out)->get();
1573   dw = w->getDoubleValue();
1574
1575   cerr << "sqrt(" << dv << ") = " << dw << endl;
1576   CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1577
1578   u = AtomAny::New((double) -3.5);
1579   in->edInit("Cpp",u);
1580   CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1581
1582   u->decrRef();
1583   v->decrRef();
1584
1585   delete node;
1586
1587 }
1588
1589 void RuntimeTest::createGraphWithCppNodes()
1590 {
1591   ElementaryNode * n1, * n2;
1592   InputPort  *in1, *in2;
1593   OutputPort  *out1, *out2;
1594
1595   n1 = _myRuntime->createCompoNode(CppNode::KIND, "test1");
1596   n2 = _myRuntime->createScriptNode(PythonNode::KIND, "test2");
1597
1598   CppComponent *C = new CppComponent("TestComponent");
1599   ((CppNode *) n1)->setComponent(C);
1600   C->decrRef();
1601   ((CppNode *) n1)->setMethod("f");
1602   in1  = n1->edAddInputPort("i",  _tc_double);
1603   out1  = n1->edAddOutputPort("o",  _tc_double);
1604
1605   ((InlineNode*) n2)->setScript("a=a+1\n");
1606   in2  = n2->edAddInputPort("a",  _tc_double);
1607   out2  = n2->edAddOutputPort("a",  _tc_double);
1608
1609   Bloc * loopBody = _myRuntime->createBloc("LoopBody");
1610   loopBody->edAddChild(n1);
1611   loopBody->edAddChild(n2);
1612   loopBody->edAddLink(out1, in2);
1613   loopBody->edAddLink(out2, in1);
1614
1615   ForLoop *loop=_myRuntime->createForLoop("Loop");
1616   loop->edSetNode(loopBody);
1617   InputPort *iNbTimes=loop->edGetNbOfTimesInputPort();
1618   iNbTimes->edInit(5);
1619
1620   Bloc * graph = _myRuntime->createBloc("graph");
1621   graph->edAddChild(loop);
1622
1623   DEBTRACE("n1->getInputPort(\"in\") = " << n1->getInputPort("i")->getName())
1624
1625   in1->edInit(4.5);
1626   in2->edInit(0.0);
1627
1628   Executor exe;
1629   exe.RunW(graph);
1630
1631   DEBTRACE(out2->dump());
1632
1633   delete graph;
1634 }
1635
1636 void RuntimeTest::classTeardown()
1637 {
1638   if (endTests) return;
1639
1640   endTests = true;
1641
1642   delete _blocMap["Bloc_3"];
1643   delete _blocMap["Bloc_2"];
1644   delete _nodeMap["Node_4"];
1645   delete _nodeMap["Node_5"];
1646   delete _nodeMap["Node_6"];
1647   delete _nodeMap["Node_7"];
1648   delete _nodeMap["Node_8"];
1649   delete _nodeMap["Node_9"];
1650
1651   _tc_seqC->decrRef();
1652   _tc_C->decrRef();
1653   list<TypeCodeObjref *>::iterator i;
1654   for (i=_ltc.begin(); i != _ltc.end(); i++)
1655     (*i)->decrRef();
1656
1657   _tc_seqseqobj->decrRef();
1658   _tc_seqobj->decrRef();
1659
1660
1661   _tc->decrRef();
1662   _tc_seqseqdble->decrRef();
1663   _tc_seqdble->decrRef();
1664   _tc_seqstr->decrRef();
1665   _tc_seqlong->decrRef();
1666   _tc_string->decrRef();
1667
1668   _myRuntime->fini();
1669   delete _myRuntime;
1670 }
1671