1 // Copyright (C) 2006-2008 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
21 #include "TypeConversions.hxx"
23 #include "ElementaryNode.hxx"
25 #include "ForLoop.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"
39 #include "runtimeTest.hxx"
51 #include "YacsTrace.hxx"
53 using namespace YACS::ENGINE;
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);
72 list<TypeCodeObjref *> RuntimeTest::_ltc;
73 TypeCode *RuntimeTest::_tc_C;
74 TypeCode *RuntimeTest::_tc_seqC;
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;
83 void RuntimeTest::setUp()
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);
94 #define cRef(x) cerr << "_tc" << #x << " : " << _tc ## x->getRefCnt() << endl
96 void RuntimeTest::tearDown()
101 void RuntimeTest::initRuntimeTypeCode()
104 std::cerr << std::endl;
105 RuntimeSALOME::setRuntime();
106 _myRuntime = getRuntime();
108 // --- init typecodes
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));
121 void RuntimeTest::createPythonNodes()
123 // --- Nodes 0 a 4 : Python
125 for (int i=0; i<5; i++)
128 ss << "Node_" << _inode++;
130 ElementaryNode* node = _myRuntime->createScriptNode("",s);
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);
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);
166 void RuntimeTest::createCORBANodes()
168 // --- Nodes 5 a 9 : CORBA
170 for (int i=5; i<10; i++)
173 ss << "Node_" << _inode++;
175 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
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);
211 void RuntimeTest::createBloc()
213 DEBTRACE(" --- create bloc, add two nodes, check constituants" );
215 // --- Bloc_0 with Node_0 and Node_1
218 ss << "Bloc_" << _ibloc++;
220 Bloc* bloc = new Bloc(s);
223 bloc->edAddChild(_nodeMap["Node_0"]);
224 bloc->edAddChild(_nodeMap["Node_1"]);
226 list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
227 CPPUNIT_ASSERT(setelem.size() == 2);
231 // --- Bloc_1 with Node_2
234 ss << "Bloc_" << _ibloc++;
236 Bloc* bloc = new Bloc(s);
239 bloc->edAddChild(_nodeMap["Node_2"]);
242 DEBTRACE(" --- add a node already used in the bloc does nothing (return false)" );
243 CPPUNIT_ASSERT( ! _blocMap["Bloc_0"]->edAddChild(_nodeMap["Node_1"]));
245 DEBTRACE(" --- add a node already used elsewhere raises exception " );
246 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_1"]->edAddChild(_nodeMap["Node_1"]),
251 void RuntimeTest::createRecursiveBlocs()
253 DEBTRACE(" --- recursive blocs, check constituants" );
255 // --- Bloc_2 with Bloc_1 and Bloc_2
258 ss << "Bloc_" << _ibloc++;
260 Bloc* bloc = new Bloc(s);
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
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++)
273 DEBTRACE(" elem name = " << (*it)->getName());
279 void RuntimeTest::createDataLinks()
281 DEBTRACE(" --- create and delete data links" );
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);
289 _blocMap["Bloc_0"]->edAddLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
290 _nodeMap["Node_1"]->getInputPort("ii2"));
291 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
293 _blocMap["Bloc_0"]->edRemoveLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
294 _nodeMap["Node_1"]->getInputPort("ii2"));
295 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
299 void RuntimeTest::createPythonNodesWithScript()
301 DEBTRACE(" --- create python nodes with scripts" );
303 // --- Node 10 : Python
307 ss << "Node_" << _inode++;
309 ElementaryNode* node = _myRuntime->createScriptNode("",s);
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);
319 // --- Node 11 : Python
323 ss << "Node_" << _inode++;
325 ElementaryNode* node = _myRuntime->createScriptNode("",s);
327 ((InlineNode*) node)->setScript("a=b+1\n"
331 "seqdble=[1.5,2.4]\n"
333 "dblevecvec=[[1.5,2.4],[6.7,7.8]]\n"
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);
344 // --- Node 12 : Python
348 ss << "Node_" << _inode++;
350 ElementaryNode* node = _myRuntime->createScriptNode("",s);
352 ((InlineNode*) node)->setScript("a=dble+1\n"
355 InputPort *i1 = node->edAddInputPort("dble", _tc_double);
356 OutputPort *o1 = node->edAddOutputPort("dble", _tc_double);
359 // --- Node 13 : Python
363 ss << "Node_" << _inode++;
365 ElementaryNode* node = _myRuntime->createScriptNode("",s);
367 ((InlineNode*) node)->setScript("print 'node 13'\n"
370 "o=ob._narrow(eo.Obj)\n"
372 "print o.echoLong(13)\n"
376 "print '++++++++',s,'+++++++++++++'\n"
378 "seqstr=['aaa','bbb']\n"
380 "seqseqobj=[[o,o],[o,o]]\n"
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);
407 // --- Node 14 : Python
411 ss << "Node_" << _inode++;
413 ElementaryNode* node = _myRuntime->createScriptNode("",s);
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"
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);
441 // --- Node 15 : Python
445 ss << "Node_" << _inode++;
447 ElementaryNode* node = _myRuntime->createScriptNode("",s);
449 ((InlineNode*) node)->setScript("print li\n"
450 "li=[2*e for e in li]\n"
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);
467 void RuntimeTest::createCORBANodesWithMethod()
469 DEBTRACE(" --- create CORBA nodes" );
471 // --- Node 16 : CORBA
475 ss << "Node_" << _inode++;
477 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
490 // --- Node 17 - 18 : CORBA
492 for (int i =0; i <2; i++)
495 ss << "Node_" << _inode++;
497 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
505 // --- Node 19 : CORBA
509 ss << "Node_" << _inode++;
511 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
521 // --- Node 20, 21, 22 : CORBA
523 for (int i =0; i <3; i++)
526 ss << "Node_" << _inode++;
528 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
546 // --- Node 23 a 26 : CORBA
548 for (int i =0; i <4; i++)
551 ss << "Node_" << _inode++;
553 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
563 // --- Node 27 : CORBA
567 ss << "Node_" << _inode++;
569 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
579 // --- Node 28 : CORBA
583 ss << "Node_" << _inode++;
585 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
595 // --- Node 29 : CORBA
599 ss << "Node_" << _inode++;
601 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
611 // --- Node 30 : CORBA
615 ss << "Node_" << _inode++;
617 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
627 // --- Node 31 : CORBA
631 ss << "Node_" << _inode++;
633 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
643 // --- Node 32 : CORBA
647 ss << "Node_" << _inode++;
649 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
657 // --- Node 33 : CORBA
661 ss << "Node_" << _inode++;
663 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
671 // --- Node 34 : CORBA
675 ss << "Node_" << _inode++;
677 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
685 // --- Node 35 : CORBA
689 ss << "Node_" << _inode++;
691 ElementaryNode* node = _myRuntime->createRefNode("",s);
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);
701 void RuntimeTest::createXMLNodes()
703 DEBTRACE(" --- create XML nodes" );
709 ss << "Node_" << _inode++;
711 ElementaryNode* node = _myRuntime->createRefNode("xmlsh",s);
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);
728 void RuntimeTest::createBloc2()
730 DEBTRACE(" --- create Bloc with all nodes" );
732 // --- Bloc_3 with Node_10 and following
736 ss << "Bloc_" << _ibloc++;
738 Bloc* bloc = new Bloc(s);
741 for (int i=10; i<_inode; i++)
745 string sn = ssn.str();
747 bloc->edAddChild(_nodeMap[sn]);
750 list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
751 CPPUNIT_ASSERT(setelem.size() == _inode - 10);
754 set<InputPort *> unitialized = _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
755 DEBTRACE(unitialized.size());
756 CPPUNIT_ASSERT(! _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
760 void RuntimeTest::createDataLinksPythonPython()
762 DEBTRACE(" --- create data links, python to python" );
765 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
766 _nodeMap["Node_11"]->getInputPort("b"));
769 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
770 _nodeMap["Node_12"]->getInputPort("dble"));
772 // --- Python sequence<double> -> Python sequence<double>
773 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_14"]->getOutputPort("li"),
774 _nodeMap["Node_15"]->getInputPort("li"));
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"));
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);
785 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
786 _nodeMap["Node_12"]->getInputPort("dble")),
787 YACS::ENGINE::ConversionException);
789 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
790 _nodeMap["Node_12"]->getInputPort("dble")),
791 YACS::ENGINE::ConversionException);
795 void RuntimeTest::createDataLinksPythonCORBA()
797 DEBTRACE(" --- create data links, python to CORBA" );
799 // --- double->double
800 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("c"),
801 _nodeMap["Node_16"]->getInputPort("a"));
804 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("i"),
805 _nodeMap["Node_19"]->getInputPort("long"));
808 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
809 _nodeMap["Node_20"]->getInputPort("str"));
810 cerr << "##### 3" << endl;
812 // --- seq<long> -> seq<double>
813 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
814 _nodeMap["Node_23"]->getInputPort("dblevec"));
816 // --- seq<long> -> seq<long>
817 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
818 _nodeMap["Node_31"]->getInputPort("lngvec"));
820 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
821 _nodeMap["Node_22"]->getInputPort("obj"));
823 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
824 _nodeMap["Node_26"]->getInputPort("dblevec"));
826 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
827 _nodeMap["Node_27"]->getInputPort("strvec"));
829 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqobj"),
830 _nodeMap["Node_28"]->getInputPort("objvec"));
832 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
833 _nodeMap["Node_29"]->getInputPort("dblevecvec"));
835 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqseqobj"),
836 _nodeMap["Node_30"]->getInputPort("objvecvec"));
838 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
839 _nodeMap["Node_27"]->getInputPort("strvec")),
840 YACS::ENGINE::ConversionException);
842 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
843 _nodeMap["Node_22"]->getInputPort("str")),
844 YACS::ENGINE::ConversionException);
846 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
847 _nodeMap["Node_22"]->getInputPort("str")),
848 YACS::ENGINE::ConversionException);
850 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("lng"),
851 _nodeMap["Node_22"]->getInputPort("str")),
852 YACS::ENGINE::ConversionException);
854 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
855 _nodeMap["Node_22"]->getInputPort("long")),
856 YACS::ENGINE::ConversionException);
858 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
859 _nodeMap["Node_24"]->getInputPort("dblevec")),
860 YACS::ENGINE::ConversionException);
862 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
863 _nodeMap["Node_24"]->getInputPort("dblevec")),
864 YACS::ENGINE::ConversionException);
866 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
867 _nodeMap["Node_24"]->getInputPort("dblevec")),
868 YACS::ENGINE::ConversionException);
872 void RuntimeTest::createDataLinksCORBACORBA()
874 DEBTRACE(" --- create data links, CORBA to CORBA" );
877 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
878 _nodeMap["Node_17"]->getInputPort("b"));
881 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
882 _nodeMap["Node_18"]->getInputPort("b"));
884 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
885 _nodeMap["Node_21"]->getInputPort("double")),
886 YACS::ENGINE::ConversionException);
888 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
889 _nodeMap["Node_31"]->getInputPort("lngvec")),
890 YACS::ENGINE::ConversionException);
892 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
893 _nodeMap["Node_27"]->getInputPort("strvec")),
894 YACS::ENGINE::ConversionException);
896 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
897 _nodeMap["Node_20"]->getInputPort("obj"));
899 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_18"]->getOutputPort("c"),
900 _nodeMap["Node_20"]->getInputPort("double"));
902 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
903 _nodeMap["Node_21"]->getInputPort("double"));
905 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
906 _nodeMap["Node_21"]->getInputPort("long"));
908 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
909 _nodeMap["Node_21"]->getInputPort("str"));
911 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("obj"),
912 _nodeMap["Node_21"]->getInputPort("obj"));
914 // Corba sequence<double> -> Corba sequence<double>
915 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
916 _nodeMap["Node_24"]->getInputPort("dblevec"));
918 // Corba sequence<double> -> Corba sequence<double>
919 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
920 _nodeMap["Node_25"]->getInputPort("dblevec"));
922 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
923 _nodeMap["Node_22"]->getInputPort("double"));
925 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
926 _nodeMap["Node_22"]->getInputPort("long"));
928 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
929 _nodeMap["Node_22"]->getInputPort("str"));
933 void RuntimeTest::createDataLinksCORBAPython()
935 DEBTRACE(" --- create data links, CORBA to Python" );
937 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("double"),
938 _nodeMap["Node_13"]->getInputPort("lng")),
939 YACS::ENGINE::ConversionException);
941 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
942 _nodeMap["Node_13"]->getInputPort("s")),
943 YACS::ENGINE::ConversionException);
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"));
950 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("double"),
951 _nodeMap["Node_13"]->getInputPort("dble"));
953 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("long"),
954 _nodeMap["Node_13"]->getInputPort("lng"));
956 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("str"),
957 _nodeMap["Node_13"]->getInputPort("s"));
959 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("obj"),
960 _nodeMap["Node_13"]->getInputPort("ob"));
962 // --- Corba sequence<double> -> Python sequence<double>
963 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
964 _nodeMap["Node_14"]->getInputPort("li"));
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"));
970 // --- Corba sequence<object> -> Python sequence<object>
971 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_28"]->getOutputPort("objvec"),
972 _nodeMap["Node_14"]->getInputPort("lobj"));
974 // --- Corba sequence<string> -> Python sequence<string>
975 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
976 _nodeMap["Node_14"]->getInputPort("lstr"));
978 // --- Corba sequence<object> -> Python sequence<object>
979 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_30"]->getOutputPort("objvecvec"),
980 _nodeMap["Node_14"]->getInputPort("llobj"));
982 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
983 _nodeMap["Node_15"]->getInputPort("lngvec"));
985 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
986 _nodeMap["Node_15"]->getInputPort("dblevec"));
990 void RuntimeTest::createDataLinksXML()
992 DEBTRACE(" --- create data links, xml nodes" );
994 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
995 _nodeMap["Node_36"]->getInputPort("dblevec")),
996 YACS::ENGINE::ConversionException);
998 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
999 _nodeMap["Node_36"]->getInputPort("dble")),
1000 YACS::ENGINE::ConversionException);
1002 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1003 _nodeMap["Node_33"]->getInputPort("dble")),
1004 YACS::ENGINE::ConversionException);
1006 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1007 _nodeMap["Node_34"]->getInputPort("dblevec")),
1008 YACS::ENGINE::ConversionException);
1010 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
1011 _nodeMap["Node_36"]->getInputPort("dble"));
1013 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
1014 _nodeMap["Node_36"]->getInputPort("dblevec"));
1016 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_29"]->getOutputPort("dblevecvec"),
1017 _nodeMap["Node_36"]->getInputPort("dblevecvec"));
1019 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1020 _nodeMap["Node_33"]->getInputPort("dble"));
1022 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1023 _nodeMap["Node_34"]->getInputPort("dblevec"));
1025 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevecvec"),
1026 _nodeMap["Node_35"]->getInputPort("dblevecvec"));
1030 void RuntimeTest::manualInitInputPort()
1032 DEBTRACE(" --- InputPort initialization" );
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++)
1040 DEBTRACE(_blocMap["Bloc_3"]->getInPortName(*iter));
1043 _nodeMap["Node_10"]->getInputPort("a")->edInit(10.51);
1045 // CORBA::Any anyLong;
1046 // anyLong <<= (CORBA::Long) 1;
1048 _nodeMap["Node_20"]->getInputPort("long")->edInit(1);
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)
1055 aString <<= (const char *)"texte";
1056 _nodeMap["Node_20"]->getInputPort("str")->put(&aString);
1057 // _nodeMap["Node_20"]->getInputPort("str")->edInit("texte");
1061 set<InputPort *> unitialized = _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
1062 DEBTRACE(unitialized.size());
1063 CPPUNIT_ASSERT( _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
1072 DEBTRACE("Python input port double");
1073 InputPort* inport=_nodeMap["Node_10"]->getInputPort("a");
1075 DEBTRACE("Initialize port with C++ double value");
1076 a = AtomAny::New(d);
1077 inport->edInit("Cpp",a);
1079 pyob=((InputPyPort*)inport)->getPyObj();
1080 DEBTRACE(pyob->ob_refcnt);
1081 CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
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);
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.);
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);
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);
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);
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();
1129 DEBTRACE("l = " << l);
1130 CPPUNIT_ASSERT(l == 10);
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();
1138 CPPUNIT_ASSERT_DOUBLES_EQUAL(10.51,d, 1e-12);
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>");
1151 void RuntimeTest::manualExecuteNoThread()
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"])
1158 DEBTRACE(" --- execution Python Node_11" );
1159 ((ElementaryNode*)_nodeMap["Node_11"])->load();
1160 ((ElementaryNode*)_nodeMap["Node_11"])->execute();
1162 DEBTRACE(" --- execution Python Node_12" );
1163 ((ElementaryNode*)_nodeMap["Node_12"])->load();
1164 ((ElementaryNode*)_nodeMap["Node_12"])->execute();
1166 DEBTRACE(" --- execution CORBA Node_16" );
1167 ((ElementaryNode*)_nodeMap["Node_16"])->load();
1168 ((ElementaryNode*)_nodeMap["Node_16"])->execute();
1170 DEBTRACE(" --- execution CORBA Node_17" );
1171 ((ElementaryNode*)_nodeMap["Node_17"])->load();
1172 ((ElementaryNode*)_nodeMap["Node_17"])->execute();
1174 DEBTRACE(" --- execution CORBA Node_18" );
1175 ((ElementaryNode*)_nodeMap["Node_18"])->load();
1176 ((ElementaryNode*)_nodeMap["Node_18"])->execute();
1178 DEBTRACE(" --- execution CORBA Node_19" );
1179 ((ElementaryNode*)_nodeMap["Node_19"])->load();
1180 ((ElementaryNode*)_nodeMap["Node_19"])->execute();
1182 DEBTRACE(" --- execution CORBA Node_20" );
1183 ((ElementaryNode*)_nodeMap["Node_20"])->load();
1184 ((ElementaryNode*)_nodeMap["Node_20"])->execute();
1186 DEBTRACE(" --- execution CORBA Node_21" );
1187 ((ElementaryNode*)_nodeMap["Node_21"])->load();
1188 ((ElementaryNode*)_nodeMap["Node_21"])->execute();
1190 DEBTRACE(" --- execution CORBA Node_29" );
1191 ((ElementaryNode*)_nodeMap["Node_29"])->load();
1192 ((ElementaryNode*)_nodeMap["Node_29"])->execute();
1194 DEBTRACE(" --- execution Python Node_13" );
1195 ((ElementaryNode*)_nodeMap["Node_13"])->load();
1196 ((ElementaryNode*)_nodeMap["Node_13"])->execute();
1198 DEBTRACE(" --- execution CORBA Node_22" );
1199 ((ElementaryNode*)_nodeMap["Node_22"])->load();
1200 ((ElementaryNode*)_nodeMap["Node_22"])->execute();
1202 DEBTRACE(" --- execution CORBA Node_23" );
1203 ((ElementaryNode*)_nodeMap["Node_23"])->load();
1204 ((ElementaryNode*)_nodeMap["Node_23"])->execute();
1206 DEBTRACE(" --- execution CORBA Node_24" );
1207 ((ElementaryNode*)_nodeMap["Node_24"])->load();
1208 ((ElementaryNode*)_nodeMap["Node_24"])->execute();
1210 DEBTRACE(" --- execution CORBA Node_27" );
1211 ((ElementaryNode*)_nodeMap["Node_27"])->load();
1212 ((ElementaryNode*)_nodeMap["Node_27"])->execute();
1214 DEBTRACE(" --- execution CORBA Node_28" );
1215 ((ElementaryNode*)_nodeMap["Node_28"])->load();
1216 ((ElementaryNode*)_nodeMap["Node_28"])->execute();
1218 DEBTRACE(" --- execution CORBA Node_30" );
1219 ((ElementaryNode*)_nodeMap["Node_30"])->load();
1220 ((ElementaryNode*)_nodeMap["Node_30"])->execute();
1222 DEBTRACE(" --- execution CORBA Node_32" );
1223 ((ElementaryNode*)_nodeMap["Node_32"])->load();
1224 ((ElementaryNode*)_nodeMap["Node_32"])->execute();
1226 DEBTRACE(" --- execution CORBA Node_26" );
1227 ((ElementaryNode*)_nodeMap["Node_26"])->load();
1228 ((ElementaryNode*)_nodeMap["Node_26"])->execute();
1230 DEBTRACE(" --- execution CORBA Node_31" );
1231 ((ElementaryNode*)_nodeMap["Node_31"])->load();
1232 ((ElementaryNode*)_nodeMap["Node_31"])->execute();
1234 DEBTRACE(" --- execution Python Node_14" );
1235 ((ElementaryNode*)_nodeMap["Node_14"])->load();
1236 ((ElementaryNode*)_nodeMap["Node_14"])->execute();
1238 DEBTRACE(" --- execution Python Node_15" );
1239 ((ElementaryNode*)_nodeMap["Node_15"])->load();
1240 ((ElementaryNode*)_nodeMap["Node_15"])->execute();
1242 DEBTRACE(" --- execution XML Node_36" );
1243 ((ElementaryNode*)_nodeMap["Node_36"])->load();
1244 ((ElementaryNode*)_nodeMap["Node_36"])->execute();
1246 DEBTRACE(" --- execution CORBA Node_33" );
1247 ((ElementaryNode*)_nodeMap["Node_33"])->load();
1248 ((ElementaryNode*)_nodeMap["Node_33"])->execute();
1250 DEBTRACE(" --- execution CORBA Node_34" );
1251 ((ElementaryNode*)_nodeMap["Node_34"])->load();
1252 ((ElementaryNode*)_nodeMap["Node_34"])->execute();
1254 DEBTRACE(" --- execution CORBA Node_35" );
1255 ((ElementaryNode*)_nodeMap["Node_35"])->load();
1256 ((ElementaryNode*)_nodeMap["Node_35"])->execute();
1258 DEBTRACE(" --- end of execution" );
1262 void RuntimeTest::manualGetOutputs()
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);
1271 // DEBTRACE("a: " << &a);
1272 // DEBTRACE("a.value(): " << a.value());
1274 x= ((InputCorbaPort*)_nodeMap["Node_16"]->getInputPort("a"))->getAny();
1275 DEBTRACE("CORBA Node_16 input a any: " << x);
1277 DEBTRACE("CORBA Node_16 input a double: " << l);
1279 *((InputCorbaPort*)_nodeMap["Node_17"]->getInputPort("b"))->getAny() >>= l;
1280 DEBTRACE("CORBA Node_17 input b double: " << l);
1282 *((InputCorbaPort*)_nodeMap["Node_18"]->getInputPort("b"))->getAny() >>= l;
1283 DEBTRACE("CORBA Node_18 input a double: " << l);
1285 *((OutputCorbaPort*)_nodeMap["Node_16"]->getOutputPort("c"))->getAny() >>= l;
1286 DEBTRACE("CORBA Node_16 output c double: " << l);
1288 *((OutputCorbaPort*)_nodeMap["Node_17"]->getOutputPort("c"))->getAny() >>= l;
1289 DEBTRACE("CORBA Node_17 output c double: " << l);
1291 *((OutputCorbaPort*)_nodeMap["Node_18"]->getOutputPort("c"))->getAny() >>= l;
1292 DEBTRACE("CORBA Node_18 output c double: " << l);
1294 DEBTRACE(" --- fini" );
1297 void RuntimeTest::createCppNodes()
1300 string s = "Node_Cpp";
1301 ElementaryNode* node = _myRuntime->createCompoNode("Cpp",s);
1303 InputPort *i1 = node->edAddInputPort("id1", _tc_double);
1304 InputPort *i2 = node->edAddInputPort("ii2", _tc_int);
1306 OutputPort *o3 = node->edAddOutputPort("os3", _tc_string);
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"));
1314 CPPUNIT_ASSERT_EQUAL(node->getInputPort("id1"),i1);
1315 CPPUNIT_ASSERT_EQUAL(node->getOutputPort("os3"),o3);
1320 void RuntimeTest::convertPorts()
1322 const char *type[] = { "Cpp", "CORBA", "Python", "XML" };
1323 int itype, jtype, ntypes = sizeof(type)/sizeof(const char *);
1325 string s0 = "Node_";
1331 for (itype=0; itype<ntypes-1; itype++)
1333 string s = s0 + type[itype];
1336 DEBTRACE("Node " << type[itype] << " creation");
1337 ElementaryNode* node;
1341 node = _myRuntime->createRefNode(type[itype],s);
1344 node = _myRuntime->createScriptNode(type[itype], s);
1347 node = _myRuntime->createRefNode("xmlsh",s);
1350 node = _myRuntime->createCompoNode(type[itype], s);
1353 InputPort *inport = node->edAddInputPort("id1", _tc_double);
1354 CPPUNIT_ASSERT(NULL != node);
1355 for (jtype=0; jtype < ntypes; jtype++)
1357 double d0= itype * 10 + jtype, d1;
1358 InputPort* pwrap=_myRuntime->adapt(inport, type[jtype], _tc_double);
1365 v = vAny = AtomAny::New(d0);
1369 cAny <<= (CORBA::Double) d0;
1372 v = pAny = PyFloat_FromDouble(d0);
1377 os << "<value><double>" << d0 << "</double></value>";
1387 if ((itype == 2) && (jtype == 2))
1389 std::cerr << "s = " << s << endl;
1392 DEBTRACE("Put a " << type[jtype] << " double (" << d0 << ") in " << s);
1401 Any * a=((InputCppPort*)inport)->getCppObj();
1402 CPPUNIT_ASSERT(a->getType()->isA(_tc_double));
1403 d1 = a->getDoubleValue();
1408 CORBA::Any * a = ((InputCorbaPort*)inport)->getAny();
1409 CPPUNIT_ASSERT(a->type()->equal(CORBA::_tc_double));
1417 PyObject *a = ((InputPyPort*)inport)->getPyObj();
1418 CPPUNIT_ASSERT(PyFloat_Check(a));
1419 d1 = PyFloat_AsDouble(a);
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--;
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>")));
1434 d1 = strtod(a2, &err);
1435 CPPUNIT_ASSERT(err == a3);
1440 CPPUNIT_ASSERT_DOUBLES_EQUAL(d0, d1, 1e-12);
1454 if (pwrap != inport) delete pwrap;
1460 void myTestRun(int nIn, int nOut, Any **In, Any **Out) throw (YACS::Exception)
1463 cerr << "myTestRun nIn = " << nIn << endl;
1464 cerr << "myTestRun nOut = " << nOut << endl;
1466 x = In[0]->getDoubleValue();
1471 Out[0] = AtomAny::New(y);
1475 throw YACS::Exception("myTestRun : input must be a positive or null real");
1480 void RuntimeTest::executeCppNode()
1482 cerr << endl << endl;
1487 DEBTRACE("execute a CppNode with an internal C++ implementation")
1488 ServiceNode * node = _myRuntime->createCompoNode("Cpp", "test");
1489 ((CppNode *) node)->setFunc(myTestRun);
1491 InputPort *in = node->edAddInputPort("in", _tc_double);
1492 OutputPort *out = node->edAddOutputPort("out", _tc_double);
1496 v = AtomAny::New(dv);
1497 in->edInit("Cpp",v);
1501 w = ((OutputCppPort *) out)->get();
1502 dw = w->getDoubleValue();
1504 cerr << "sqrt(" << dv << ") = " << dw << endl;
1505 CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1507 u = AtomAny::New((double) -3.5);
1508 in->edInit("Cpp",u);
1509 CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1517 DEBTRACE("execute a CppNode with an external C++ implementation (in a dynamic library)");
1519 node = _myRuntime->createCompoNode("Cpp", "test");
1520 CppComponent * C = new CppComponent("TestComponent");
1521 node->setComponent(C);
1522 node->setMethod("f");
1524 in = node->edAddInputPort("in", _tc_double);
1525 out = node->edAddOutputPort("out", _tc_double);
1529 v = AtomAny::New(dv);
1530 in->edInit("Cpp",v);
1534 w = ((OutputCppPort *) out)->get();
1535 dw = w->getDoubleValue();
1537 cerr << "sqrt(" << dv << ") = " << dw << endl;
1538 CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1540 u = AtomAny::New((double) -3.5);
1541 in->edInit("Cpp",u);
1542 CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1552 void RuntimeTest::createGraphWithCppNodes()
1554 ElementaryNode * n1, * n2;
1555 InputPort *in1, *in2;
1556 OutputPort *out1, *out2;
1558 n1 = _myRuntime->createCompoNode(CppNode::KIND, "test1");
1559 n2 = _myRuntime->createScriptNode(PythonNode::KIND, "test2");
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);
1567 ((InlineNode*) n2)->setScript("a=a+1\n");
1568 in2 = n2->edAddInputPort("a", _tc_double);
1569 out2 = n2->edAddOutputPort("a", _tc_double);
1571 Bloc * loopBody = _myRuntime->createBloc("LoopBody");
1572 loopBody->edAddChild(n1);
1573 loopBody->edAddChild(n2);
1574 loopBody->edAddLink(out1, in2);
1575 loopBody->edAddLink(out2, in1);
1577 ForLoop *loop=_myRuntime->createForLoop("Loop");
1578 loop->edSetNode(loopBody);
1579 InputPort *iNbTimes=loop->edGetNbOfTimesInputPort();
1580 iNbTimes->edInit(5);
1582 Bloc * graph = _myRuntime->createBloc("graph");
1583 graph->edAddChild(loop);
1585 DEBTRACE("n1->getInputPort(\"in\") = " << n1->getInputPort("i")->getName())
1593 DEBTRACE(out2->dump());
1598 void RuntimeTest::classTeardown()
1600 if (endTests) return;
1603 _tc_seqC->decrRef();
1605 list<TypeCodeObjref *>::iterator i;
1606 for (i=_ltc.begin(); i != _ltc.end(); i++)
1609 _tc_seqseqobj->decrRef();
1610 _tc_seqobj->decrRef();
1614 _tc_seqseqdble->decrRef();
1615 _tc_seqdble->decrRef();
1616 _tc_seqstr->decrRef();
1617 _tc_seqlong->decrRef();
1618 _tc_string->decrRef();