src/runtime/Test/runtimeTest.cxx

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