1 // Copyright (C) 2006-2019 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, or (at your option) any later version.
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
20 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
22 #include "TypeConversions.hxx"
24 #include "ElementaryNode.hxx"
26 #include "ForLoop.hxx"
28 #include "CppNode.hxx"
29 #include "PythonNode.hxx"
30 #include "InlineNode.hxx"
31 #include "ServiceNode.hxx"
32 #include "XMLNode.hxx"
33 #include "PythonPorts.hxx"
34 #include "XMLPorts.hxx"
35 #include "CORBAPorts.hxx"
36 #include "CppPorts.hxx"
37 #include "CppComponent.hxx"
38 #include "Executor.hxx"
40 #include "runtimeTest.hxx"
52 #include "YacsTrace.hxx"
54 using namespace YACS::ENGINE;
60 TypeCode *RuntimeTest::_tc_double = new TypeCode(Double);
61 TypeCode *RuntimeTest::_tc_int = new TypeCode(Int);
62 TypeCode *RuntimeTest::_tc_string = new TypeCode(String);
63 TypeCode *RuntimeTest::_tc = TypeCode::interfaceTc("id","name");
64 //TypeCode *RuntimeTest::_tc_obj = TypeCode::interfaceTc("eo::Obj","IDL:eo/Obj:1.0");
65 TypeCode *RuntimeTest::_tc_obj = TypeCode::interfaceTc("IDL:eo/Obj:1.0","Obj");
66 TypeCode *RuntimeTest::_tc_seqdble = TypeCode::sequenceTc("eo:seqdouble","seqdouble",RuntimeTest::_tc_double);
67 TypeCode *RuntimeTest::_tc_seqstr = TypeCode::sequenceTc("eo:seqstring","seqstring",RuntimeTest::_tc_string);
68 TypeCode *RuntimeTest::_tc_seqlong = TypeCode::sequenceTc("eo:seqlong","seqlong",RuntimeTest::_tc_int);
69 TypeCode *RuntimeTest::_tc_seqobj = TypeCode::sequenceTc("eo:seqobj","seqobj",RuntimeTest::_tc_obj);
70 TypeCode *RuntimeTest::_tc_seqseqdble= TypeCode::sequenceTc("eo:seqseqdble","seqseqdble",RuntimeTest::_tc_seqdble);
71 TypeCode *RuntimeTest::_tc_seqseqobj = TypeCode::sequenceTc("eo:seqseqobj","seqseqobj",RuntimeTest::_tc_seqobj);
73 list<TypeCodeObjref *> RuntimeTest::_ltc;
74 TypeCode *RuntimeTest::_tc_C;
75 TypeCode *RuntimeTest::_tc_seqC;
77 map<string, Node*> RuntimeTest::_nodeMap;
78 map<string, Bloc*> RuntimeTest::_blocMap;
79 int RuntimeTest::_inode = 0;
80 int RuntimeTest::_ibloc = 0;
81 Runtime *RuntimeTest::_myRuntime = 0;
82 bool RuntimeTest::endTests = false;
84 RuntimeForTest::RuntimeForTest()
85 : RuntimeSALOME(UsePython+UseCorba+UseXml+UseCpp+UseSalome, 0, nullptr)
89 RuntimeForTest::~RuntimeForTest()
93 std::vector< std::pair<std::string,int> >
94 RuntimeForTest::getCatalogOfComputeNodes() const
96 std::vector< std::pair<std::string,int> > result(1);
97 std::pair<std::string,int> localhost;
98 localhost.first = "localhost";
100 result[0] = localhost;
104 void RuntimeForTest::setRuntime()
106 if (! Runtime::_singleton)
107 Runtime::_singleton = new RuntimeForTest;
110 void RuntimeTest::setUp()
112 if (_ltc.size() == 0)
114 _ltc.push_back((TypeCodeObjref *)_tc_obj);
115 _tc_C = TypeCode::interfaceTc("IDL:eo/C:1.0","C",_ltc);
116 _tc_seqC = TypeCode::sequenceTc("eo:seqC","seqC",_tc_C);
121 #define cRef(x) cerr << "_tc" << #x << " : " << _tc ## x->getRefCnt() << endl
123 void RuntimeTest::tearDown()
128 void RuntimeTest::initRuntimeTypeCode()
131 std::cerr << std::endl;
132 RuntimeForTest::setRuntime();
133 _myRuntime = getRuntime();
135 // --- init typecodes
137 DEBTRACE( " " << _tc->id() << " " << _tc->name() );
138 DEBTRACE("int is a int: "); CPPUNIT_ASSERT( _tc_int->isA(_tc_int));
139 DEBTRACE("seqdble is not a seqlong: "); CPPUNIT_ASSERT(!_tc_seqdble->isA(_tc_seqlong));
140 DEBTRACE("seqdble is a seqdble: "); CPPUNIT_ASSERT( _tc_seqdble->isA(_tc_seqdble));
141 DEBTRACE("seqlong is not a seqdble: "); CPPUNIT_ASSERT(!_tc_seqlong->isA(_tc_seqdble));
142 DEBTRACE("C is a Obj: "); CPPUNIT_ASSERT( _tc_C->isA(_tc_obj));
143 DEBTRACE("Obj is not a C: " ); CPPUNIT_ASSERT(!_tc_obj->isA(_tc_C));
144 DEBTRACE("seqC is a seqObj: "); CPPUNIT_ASSERT( _tc_seqC->isA(_tc_seqobj));
145 DEBTRACE( "seqObj is not a seqC: "); CPPUNIT_ASSERT(!_tc_seqobj->isA(_tc_seqC));
148 void RuntimeTest::createPythonNodes()
150 // --- Nodes 0 a 4 : Python
152 for (int i=0; i<5; i++)
155 ss << "Node_" << _inode++;
157 ElementaryNode* node = _myRuntime->createScriptNode("",s);
159 InputPort *i1 = node->edAddInputPort("id1", _tc_double);
160 InputPort *i2 = node->edAddInputPort("ii2", _tc_int);
161 InputPort *i3 = node->edAddInputPort("is3", _tc_string);
162 InputPort *i4 = node->edAddInputPort("io4", _tc_obj);
163 InputPort *i5 = node->edAddInputPort("isd5", _tc_seqdble);
164 InputPort *i6 = node->edAddInputPort("isl6", _tc_seqlong);
165 InputPort *i7 = node->edAddInputPort("iso7", _tc_seqobj);
166 InputPort *i8 = node->edAddInputPort("issd8",_tc_seqseqdble);
167 InputPort *i9 = node->edAddInputPort("isso9",_tc_seqseqobj);
168 InputPort *i10 = node->edAddInputPort("iC10", _tc_C);
169 InputPort *i11 = node->edAddInputPort("isC11",_tc_seqC);
171 OutputPort *o1 = node->edAddOutputPort("od1", _tc_double);
172 OutputPort *o2 = node->edAddOutputPort("oi2", _tc_int);
173 OutputPort *o3 = node->edAddOutputPort("os3", _tc_string);
174 OutputPort *o4 = node->edAddOutputPort("oo4", _tc_obj);
175 OutputPort *o5 = node->edAddOutputPort("osd5", _tc_seqdble);
176 OutputPort *o6 = node->edAddOutputPort("osl6", _tc_seqlong);
177 OutputPort *o7 = node->edAddOutputPort("oso7", _tc_seqobj);
178 OutputPort *o8 = node->edAddOutputPort("ossd8",_tc_seqseqdble);
179 OutputPort *o9 = node->edAddOutputPort("osso9",_tc_seqseqobj);
180 OutputPort *o10 = node->edAddOutputPort("oC10", _tc_C);
181 OutputPort *o11 = node->edAddOutputPort("osC11",_tc_seqC);
182 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
183 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),11);
184 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),11);
185 CPPUNIT_ASSERT_EQUAL(node->getInPortName(i10),string("iC10"));
186 CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o10),string("oC10"));
187 CPPUNIT_ASSERT_EQUAL(node->getInputPort("iC10"),i10);
188 CPPUNIT_ASSERT_EQUAL(node->getOutputPort("oC10"),o10);
193 void RuntimeTest::createCORBANodes()
195 // --- Nodes 5 a 9 : CORBA
197 for (int i=5; i<10; i++)
200 ss << "Node_" << _inode++;
202 ElementaryNode* node = _myRuntime->createRefNode("",s);
204 InputPort *i1 = node->edAddInputPort("id1", _tc_double);
205 InputPort *i2 = node->edAddInputPort("ii2", _tc_int);
206 InputPort *i3 = node->edAddInputPort("is3", _tc_string);
207 InputPort *i4 = node->edAddInputPort("io4", _tc_obj);
208 InputPort *i5 = node->edAddInputPort("isd5", _tc_seqdble);
209 InputPort *i6 = node->edAddInputPort("isl6", _tc_seqlong);
210 InputPort *i7 = node->edAddInputPort("iso7", _tc_seqobj);
211 InputPort *i8 = node->edAddInputPort("issd8",_tc_seqseqdble);
212 InputPort *i9 = node->edAddInputPort("isso9",_tc_seqseqobj);
213 InputPort *i10 = node->edAddInputPort("iC10", _tc_C);
214 InputPort *i11 = node->edAddInputPort("isC11",_tc_seqC);
216 OutputPort *o1 = node->edAddOutputPort("od1", _tc_double);
217 OutputPort *o2 = node->edAddOutputPort("oi2", _tc_int);
218 OutputPort *o3 = node->edAddOutputPort("os3", _tc_string);
219 OutputPort *o4 = node->edAddOutputPort("oo4", _tc_obj);
220 OutputPort *o5 = node->edAddOutputPort("osd5", _tc_seqdble);
221 OutputPort *o6 = node->edAddOutputPort("osl6", _tc_seqlong);
222 OutputPort *o7 = node->edAddOutputPort("oso7", _tc_seqobj);
223 OutputPort *o8 = node->edAddOutputPort("ossd8",_tc_seqseqdble);
224 OutputPort *o9 = node->edAddOutputPort("osso9",_tc_seqseqobj);
225 OutputPort *o10 = node->edAddOutputPort("oC10", _tc_C);
226 OutputPort *o11 = node->edAddOutputPort("osC11",_tc_seqC);
227 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("CORBA"));
228 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),11);
229 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),11);
230 CPPUNIT_ASSERT_EQUAL(node->getInPortName(i10),string("iC10"));
231 CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o10),string("oC10"));
232 CPPUNIT_ASSERT_EQUAL(node->getInputPort("iC10"),i10);
233 CPPUNIT_ASSERT_EQUAL(node->getOutputPort("oC10"),o10);
238 void RuntimeTest::createBloc()
240 DEBTRACE(" --- create bloc, add two nodes, check constituants" );
242 // --- Bloc_0 with Node_0 and Node_1
245 ss << "Bloc_" << _ibloc++;
247 Bloc* bloc = new Bloc(s);
250 bloc->edAddChild(_nodeMap["Node_0"]);
251 bloc->edAddChild(_nodeMap["Node_1"]);
253 list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
254 CPPUNIT_ASSERT(setelem.size() == 2);
258 // --- Bloc_1 with Node_2
261 ss << "Bloc_" << _ibloc++;
263 Bloc* bloc = new Bloc(s);
266 bloc->edAddChild(_nodeMap["Node_2"]);
269 DEBTRACE(" --- add a node already used in the bloc does nothing (return false)" );
270 CPPUNIT_ASSERT( ! _blocMap["Bloc_0"]->edAddChild(_nodeMap["Node_1"]));
272 DEBTRACE(" --- add a node already used elsewhere raises exception " );
273 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_1"]->edAddChild(_nodeMap["Node_1"]),
278 void RuntimeTest::createRecursiveBlocs()
280 DEBTRACE(" --- recursive blocs, check constituants" );
282 // --- Bloc_2 with Bloc_0, Bloc_1 and Node_3
285 ss << "Bloc_" << _ibloc++;
287 Bloc* bloc = new Bloc(s);
290 bloc->edAddChild(_nodeMap["Bloc_0"]); // 2 elementary nodes
291 bloc->edAddChild(_nodeMap["Bloc_1"]); // 1 elementary node
292 bloc->edAddChild(_nodeMap["Node_3"]); // 1 elementary node
296 list<ElementaryNode *> setelem = _blocMap["Bloc_2"]->getRecursiveConstituents();
297 CPPUNIT_ASSERT(setelem.size() == 4);
298 for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
300 DEBTRACE(" elem name = " << (*it)->getName());
306 void RuntimeTest::createDataLinks()
308 DEBTRACE(" --- create and delete data links" );
310 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
311 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_0"]->edAddLink(_nodeMap["Node_0"]->getOutputPort("od1"),
312 _nodeMap["Node_1"]->getInputPort("is3")),
313 YACS::ENGINE::ConversionException);
314 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
316 _blocMap["Bloc_0"]->edAddLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
317 _nodeMap["Node_1"]->getInputPort("ii2"));
318 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
320 _blocMap["Bloc_0"]->edRemoveLink(_nodeMap["Node_0"]->getOutputPort("oi2"),
321 _nodeMap["Node_1"]->getInputPort("ii2"));
322 CPPUNIT_ASSERT(_blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
326 void RuntimeTest::createPythonNodesWithScript()
328 DEBTRACE(" --- create python nodes with scripts" );
330 // --- Node 10 : Python
334 ss << "Node_" << _inode++;
336 ElementaryNode* node = _myRuntime->createScriptNode("",s);
338 ((InlineNode*) node)->setScript("a=a+1\n");
339 InputPort *i1 = node->edAddInputPort("a", _tc_double);
340 OutputPort *o1 = node->edAddOutputPort("a", _tc_double);
341 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
342 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),1);
343 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
346 // --- Node 11 : Python
350 ss << "Node_" << _inode++;
352 ElementaryNode* node = _myRuntime->createScriptNode("",s);
354 ((InlineNode*) node)->setScript("a=b+1\n"
358 "seqdble=[1.5,2.4]\n"
360 "dblevecvec=[[1.5,2.4],[6.7,7.8]]\n"
362 InputPort *i1 = node->edAddInputPort("b", _tc_double);
363 OutputPort *o1 = node->edAddOutputPort("c", _tc_double);
364 OutputPort *o2 = node->edAddOutputPort("i", _tc_int);
365 OutputPort *o3 = node->edAddOutputPort("s", _tc_string);
366 OutputPort *o4 = node->edAddOutputPort("seqdble", _tc_seqdble);
367 OutputPort *o5 = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
368 OutputPort *o6 = node->edAddOutputPort("lngvec", _tc_seqlong);
371 // --- Node 12 : Python
375 ss << "Node_" << _inode++;
377 ElementaryNode* node = _myRuntime->createScriptNode("",s);
379 ((InlineNode*) node)->setScript("a=dble+1\n"
382 InputPort *i1 = node->edAddInputPort("dble", _tc_double);
383 OutputPort *o1 = node->edAddOutputPort("dble", _tc_double);
386 // --- Node 13 : Python
390 ss << "Node_" << _inode++;
392 ElementaryNode* node = _myRuntime->createScriptNode("",s);
394 ((InlineNode*) node)->setScript("print('node 13')\n"
397 "o=ob._narrow(eo.Obj)\n"
399 "print(o.echoLong(13))\n"
403 "print('++++++++',s,'+++++++++++++')\n"
405 "seqstr=['aaa','bbb']\n"
407 "seqseqobj=[[o,o],[o,o]]\n"
410 InputPort *i1 = node->edAddInputPort("dble", _tc_double);
411 InputPort *i2 = node->edAddInputPort("lng", _tc_int);
412 InputPort *i3 = node->edAddInputPort("s", _tc_string);
413 InputPort *i4 = node->edAddInputPort("ob", _tc_obj);
414 OutputPort *o1 = node->edAddOutputPort("dble", _tc_double);
415 OutputPort *o2 = node->edAddOutputPort("s", _tc_string);
416 OutputPort *o3 = node->edAddOutputPort("lng", _tc_int);
417 OutputPort *o4 = node->edAddOutputPort("ob", _tc_obj);
418 OutputPort *o5 = node->edAddOutputPort("seqstr", _tc_seqstr);
419 OutputPort *o6 = node->edAddOutputPort("seqobj", _tc_seqobj);
420 OutputPort *o7 = node->edAddOutputPort("seqseqobj", _tc_seqseqobj);
421 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i1)->getPyObj(), Py_None);
422 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i2)->getPyObj(), Py_None);
423 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i3)->getPyObj(), Py_None);
424 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i4)->getPyObj(), Py_None);
425 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o1)->get(), Py_None);
426 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o2)->get(), Py_None);
427 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o3)->get(), Py_None);
428 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o4)->get(), Py_None);
429 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o5)->get(), Py_None);
430 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o6)->get(), Py_None);
431 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o7)->get(), Py_None);
434 // --- Node 14 : Python
438 ss << "Node_" << _inode++;
440 ElementaryNode* node = _myRuntime->createScriptNode("",s);
442 ((InlineNode*) node)->setScript("print(li)\n"
443 "print('lili=',lili)\n"
444 "print('lstr=',lstr)\n"
445 "print('lobj=',lobj)\n"
446 "print('llobj=',llobj)\n"
447 "print('objc=',objc)\n"
450 InputPort *i1 = node->edAddInputPort("li", _tc_seqdble);
451 InputPort *i2 = node->edAddInputPort("lili", _tc_seqseqdble);
452 InputPort *i3 = node->edAddInputPort("lstr", _tc_seqstr);
453 InputPort *i4 = node->edAddInputPort("lobj", _tc_seqobj);
454 InputPort *i5 = node->edAddInputPort("llobj", _tc_seqseqobj);
455 InputPort *i6 = node->edAddInputPort("objc", _tc_C);
456 OutputPort *o1 = node->edAddOutputPort("li", _tc_seqdble);
457 OutputPort *o2 = node->edAddOutputPort("objc", _tc_C);
458 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i1)->getPyObj(), Py_None);
459 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i2)->getPyObj(), Py_None);
460 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i3)->getPyObj(), Py_None);
461 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i4)->getPyObj(), Py_None);
462 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i5)->getPyObj(), Py_None);
463 CPPUNIT_ASSERT_EQUAL(((InputPyPort *)i6)->getPyObj(), Py_None);
464 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o1)->get(), Py_None);
465 CPPUNIT_ASSERT_EQUAL(((OutputPyPort *)o2)->get(), Py_None);
468 // --- Node 15 : Python
472 ss << "Node_" << _inode++;
474 ElementaryNode* node = _myRuntime->createScriptNode("",s);
476 ((InlineNode*) node)->setScript("print(li)\n"
477 "li=[2*e for e in li]\n"
478 "print('obj=',obj)\n"
483 InputPort *i1 = node->edAddInputPort("li", _tc_seqdble);
484 InputPort *i2 = node->edAddInputPort("obj", _tc_obj);
485 InputPort *i3 = node->edAddInputPort("lngvec", _tc_seqlong);
486 InputPort *i4 = node->edAddInputPort("dblevec", _tc_seqdble);
487 OutputPort *o1 = node->edAddOutputPort("li", _tc_seqdble);
488 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Python"));
489 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),4);
490 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
494 void RuntimeTest::createCORBANodesWithMethod()
496 DEBTRACE(" --- create CORBA nodes" );
498 // --- Node 16 : CORBA
502 ss << "Node_" << _inode++;
504 ElementaryNode* node = _myRuntime->createRefNode("",s);
506 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
507 ((ServiceNode *) node)->setMethod("echoDouble");
508 InputPort *i1 = node->edAddInputPort("a", _tc_double);
509 OutputPort *o1 = node->edAddOutputPort("c", _tc_double);
510 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("CORBA"));
511 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),1);
512 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
513 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
514 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
517 // --- Node 17 - 18 : CORBA
519 for (int i =0; i <2; i++)
522 ss << "Node_" << _inode++;
524 ElementaryNode* node = _myRuntime->createRefNode("",s);
526 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
527 ((ServiceNode *) node)->setMethod("echoDouble");
528 InputPort *i1 = node->edAddInputPort("b", _tc_double);
529 OutputPort *o1 = node->edAddOutputPort("c", _tc_double);
532 // --- Node 19 : CORBA
536 ss << "Node_" << _inode++;
538 ElementaryNode* node = _myRuntime->createRefNode("",s);
540 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
541 ((ServiceNode *) node)->setMethod("createObj");
542 InputPort *i1 = node->edAddInputPort("long", _tc_int);
543 OutputPort *o1 = node->edAddOutputPort("obj", _tc_obj);
544 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
545 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
548 // --- Node 20, 21, 22 : CORBA
550 for (int i =0; i <3; i++)
553 ss << "Node_" << _inode++;
555 ElementaryNode* node = _myRuntime->createRefNode("",s);
557 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
558 ((ServiceNode *) node)->setMethod("echoAll");
559 InputPort *i1 = node->edAddInputPort("double", _tc_double);
560 InputPort *i2 = node->edAddInputPort("long", _tc_int);
561 InputPort *i3 = node->edAddInputPort("str", _tc_string);
562 InputPort *i4 = node->edAddInputPort("obj", _tc_obj);
563 OutputPort *o1 = node->edAddOutputPort("double", _tc_double);
564 OutputPort *o2 = node->edAddOutputPort("long", _tc_int);
565 OutputPort *o3 = node->edAddOutputPort("str", _tc_string);
566 OutputPort *o4 = node->edAddOutputPort("obj", _tc_obj);
567 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i3)->getAny()->type()->kind(),CORBA::tk_null);
568 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i4)->getAny()->type()->kind(),CORBA::tk_null);
569 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o3)->getAny()->type()->kind(),CORBA::tk_null);
570 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o4)->getAny()->type()->kind(),CORBA::tk_null);
573 // --- Node 23 a 26 : CORBA
575 for (int i =0; i <4; i++)
578 ss << "Node_" << _inode++;
580 ElementaryNode* node = _myRuntime->createRefNode("",s);
582 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
583 ((ServiceNode *) node)->setMethod("echoDoubleVec");
584 InputPort *i1 = node->edAddInputPort("dblevec", _tc_seqdble);
585 OutputPort *o1 = node->edAddOutputPort("dblevec", _tc_seqdble);
586 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
587 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
590 // --- Node 27 : CORBA
594 ss << "Node_" << _inode++;
596 ElementaryNode* node = _myRuntime->createRefNode("",s);
598 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
599 ((ServiceNode *) node)->setMethod("echoStrVec");
600 InputPort *i1 = node->edAddInputPort("strvec", _tc_seqstr);
601 OutputPort *o1 = node->edAddOutputPort("strvec", _tc_seqstr);
602 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
603 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
606 // --- Node 28 : CORBA
610 ss << "Node_" << _inode++;
612 ElementaryNode* node = _myRuntime->createRefNode("",s);
614 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
615 ((ServiceNode *) node)->setMethod("echoObjectVec");
616 InputPort *i1 = node->edAddInputPort("objvec", _tc_seqobj);
617 OutputPort *o1 = node->edAddOutputPort("objvec", _tc_seqobj);
618 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
619 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
622 // --- Node 29 : CORBA
626 ss << "Node_" << _inode++;
628 ElementaryNode* node = _myRuntime->createRefNode("",s);
630 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
631 ((ServiceNode *) node)->setMethod("echoDoubleVecVec");
632 InputPort *i1 = node->edAddInputPort("dblevecvec", _tc_seqseqdble);
633 OutputPort *o1 = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
634 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
635 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
638 // --- Node 30 : CORBA
642 ss << "Node_" << _inode++;
644 ElementaryNode* node = _myRuntime->createRefNode("",s);
646 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
647 ((ServiceNode *) node)->setMethod("echoObjectVecVec");
648 InputPort *i1 = node->edAddInputPort("objvecvec", _tc_seqseqobj);
649 OutputPort *o1 = node->edAddOutputPort("objvecvec", _tc_seqseqobj);
650 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
651 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
654 // --- Node 31 : CORBA
658 ss << "Node_" << _inode++;
660 ElementaryNode* node = _myRuntime->createRefNode("",s);
662 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
663 ((ServiceNode *) node)->setMethod("echoIntVec");
664 InputPort *i1 = node->edAddInputPort("lngvec", _tc_seqlong);
665 OutputPort *o1 = node->edAddOutputPort("lngvec", _tc_seqlong);
666 CPPUNIT_ASSERT_EQUAL(((InputCorbaPort *)i1)->getAny()->type()->kind(),CORBA::tk_null);
667 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
670 // --- Node 32 : CORBA
674 ss << "Node_" << _inode++;
676 ElementaryNode* node = _myRuntime->createRefNode("",s);
678 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
679 ((ServiceNode *) node)->setMethod("createC");
680 OutputPort *o1 = node->edAddOutputPort("objc", _tc_C);
681 CPPUNIT_ASSERT_EQUAL(((OutputCorbaPort *)o1)->getAny()->type()->kind(),CORBA::tk_null);
684 // --- Node 33 : CORBA
688 ss << "Node_" << _inode++;
690 ElementaryNode* node = _myRuntime->createRefNode("",s);
692 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
693 ((ServiceNode *) node)->setMethod("echoDouble");
694 InputPort *i1 = node->edAddInputPort("dble", _tc_double);
695 OutputPort *o1 = node->edAddOutputPort("dble", _tc_double);
698 // --- Node 34 : CORBA
702 ss << "Node_" << _inode++;
704 ElementaryNode* node = _myRuntime->createRefNode("",s);
706 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
707 ((ServiceNode *) node)->setMethod("echoDoubleVec");
708 InputPort *i1 = node->edAddInputPort("dblevec", _tc_seqdble);
709 OutputPort *o1 = node->edAddOutputPort("dblevec", _tc_seqdble);
712 // --- Node 35 : CORBA
716 ss << "Node_" << _inode++;
718 ElementaryNode* node = _myRuntime->createRefNode("",s);
720 ((ServiceNode *) node)->setRef("corbaname:rir:#test.my_context/Echo.Object");
721 ((ServiceNode *) node)->setMethod("echoDoubleVecVec");
722 InputPort *i1 = node->edAddInputPort("dblevecvec", _tc_seqseqdble);
723 OutputPort *o1 = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
728 void RuntimeTest::createXMLNodes()
730 DEBTRACE(" --- create XML nodes" );
736 ss << "Node_" << _inode++;
738 ElementaryNode* node = _myRuntime->createRefNode("xmlsh",s);
740 ((ServiceNode *) node)->setRef("./xmlrun.sh");
741 ((ServiceNode *) node)->setMethod("echo");
742 InputPort *i1 = node->edAddInputPort("dble", _tc_double);
743 InputPort *i2 = node->edAddInputPort("dblevec", _tc_seqdble);
744 InputPort *i3 = node->edAddInputPort("dblevecvec", _tc_seqseqdble);
745 OutputPort *o1 = node->edAddOutputPort("dble", _tc_double);
746 OutputPort *o2 = node->edAddOutputPort("dblevec", _tc_seqdble);
747 OutputPort *o3 = node->edAddOutputPort("dblevecvec", _tc_seqseqdble);
748 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("XML"));
749 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),3);
750 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),3);
755 void RuntimeTest::createBloc2()
757 DEBTRACE(" --- create Bloc with all nodes" );
759 // --- Bloc_3 with Node_10 and following
763 ss << "Bloc_" << _ibloc++;
765 Bloc* bloc = new Bloc(s);
768 for (int i=10; i<_inode; i++)
772 string sn = ssn.str();
774 bloc->edAddChild(_nodeMap[sn]);
777 list<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
778 CPPUNIT_ASSERT(setelem.size() == _inode - 10);
781 set<InputPort *> unitialized = _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
782 DEBTRACE(unitialized.size());
783 CPPUNIT_ASSERT(! _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
787 void RuntimeTest::createDataLinksPythonPython()
789 DEBTRACE(" --- create data links, python to python" );
792 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
793 _nodeMap["Node_11"]->getInputPort("b"));
796 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_10"]->getOutputPort("a"),
797 _nodeMap["Node_12"]->getInputPort("dble"));
799 // --- Python sequence<double> -> Python sequence<double>
800 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_14"]->getOutputPort("li"),
801 _nodeMap["Node_15"]->getInputPort("li"));
803 // --- Python obj C (derived from Obj) -> Python obj Obj : accepted
804 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_14"]->getOutputPort("objc"),
805 _nodeMap["Node_15"]->getInputPort("obj"));
807 // --- Python Obj -> Python C (derived from Obj) : forbidden
808 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
809 _nodeMap["Node_14"]->getInputPort("objc")),
810 YACS::ENGINE::ConversionException);
812 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
813 _nodeMap["Node_12"]->getInputPort("dble")),
814 YACS::ENGINE::ConversionException);
816 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
817 _nodeMap["Node_12"]->getInputPort("dble")),
818 YACS::ENGINE::ConversionException);
822 void RuntimeTest::createDataLinksPythonCORBA()
824 DEBTRACE(" --- create data links, python to CORBA" );
826 // --- double->double
827 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("c"),
828 _nodeMap["Node_16"]->getInputPort("a"));
831 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("i"),
832 _nodeMap["Node_19"]->getInputPort("long"));
835 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("s"),
836 _nodeMap["Node_20"]->getInputPort("str"));
837 cerr << "##### 3" << endl;
839 // --- seq<long> -> seq<double>
840 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
841 _nodeMap["Node_23"]->getInputPort("dblevec"));
843 // --- seq<long> -> seq<long>
844 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("lngvec"),
845 _nodeMap["Node_31"]->getInputPort("lngvec"));
847 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
848 _nodeMap["Node_22"]->getInputPort("obj"));
850 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
851 _nodeMap["Node_26"]->getInputPort("dblevec"));
853 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
854 _nodeMap["Node_27"]->getInputPort("strvec"));
856 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqobj"),
857 _nodeMap["Node_28"]->getInputPort("objvec"));
859 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
860 _nodeMap["Node_29"]->getInputPort("dblevecvec"));
862 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqseqobj"),
863 _nodeMap["Node_30"]->getInputPort("objvecvec"));
865 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("seqdble"),
866 _nodeMap["Node_27"]->getInputPort("strvec")),
867 YACS::ENGINE::ConversionException);
869 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("ob"),
870 _nodeMap["Node_22"]->getInputPort("str")),
871 YACS::ENGINE::ConversionException);
873 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
874 _nodeMap["Node_22"]->getInputPort("str")),
875 YACS::ENGINE::ConversionException);
877 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("lng"),
878 _nodeMap["Node_22"]->getInputPort("str")),
879 YACS::ENGINE::ConversionException);
881 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
882 _nodeMap["Node_22"]->getInputPort("long")),
883 YACS::ENGINE::ConversionException);
885 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("dble"),
886 _nodeMap["Node_24"]->getInputPort("dblevec")),
887 YACS::ENGINE::ConversionException);
889 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_11"]->getOutputPort("dblevecvec"),
890 _nodeMap["Node_24"]->getInputPort("dblevec")),
891 YACS::ENGINE::ConversionException);
893 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_13"]->getOutputPort("seqstr"),
894 _nodeMap["Node_24"]->getInputPort("dblevec")),
895 YACS::ENGINE::ConversionException);
899 void RuntimeTest::createDataLinksCORBACORBA()
901 DEBTRACE(" --- create data links, CORBA to CORBA" );
904 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
905 _nodeMap["Node_17"]->getInputPort("b"));
908 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
909 _nodeMap["Node_18"]->getInputPort("b"));
911 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
912 _nodeMap["Node_21"]->getInputPort("double")),
913 YACS::ENGINE::ConversionException);
915 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
916 _nodeMap["Node_31"]->getInputPort("lngvec")),
917 YACS::ENGINE::ConversionException);
919 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
920 _nodeMap["Node_27"]->getInputPort("strvec")),
921 YACS::ENGINE::ConversionException);
923 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_19"]->getOutputPort("obj"),
924 _nodeMap["Node_20"]->getInputPort("obj"));
926 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_18"]->getOutputPort("c"),
927 _nodeMap["Node_20"]->getInputPort("double"));
929 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
930 _nodeMap["Node_21"]->getInputPort("double"));
932 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
933 _nodeMap["Node_21"]->getInputPort("long"));
935 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
936 _nodeMap["Node_21"]->getInputPort("str"));
938 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("obj"),
939 _nodeMap["Node_21"]->getInputPort("obj"));
941 // Corba sequence<double> -> Corba sequence<double>
942 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
943 _nodeMap["Node_24"]->getInputPort("dblevec"));
945 // Corba sequence<double> -> Corba sequence<double>
946 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
947 _nodeMap["Node_25"]->getInputPort("dblevec"));
949 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
950 _nodeMap["Node_22"]->getInputPort("double"));
952 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("long"),
953 _nodeMap["Node_22"]->getInputPort("long"));
955 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("str"),
956 _nodeMap["Node_22"]->getInputPort("str"));
960 void RuntimeTest::createDataLinksCORBAPython()
962 DEBTRACE(" --- create data links, CORBA to Python" );
964 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_20"]->getOutputPort("double"),
965 _nodeMap["Node_13"]->getInputPort("lng")),
966 YACS::ENGINE::ConversionException);
968 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
969 _nodeMap["Node_13"]->getInputPort("s")),
970 YACS::ENGINE::ConversionException);
973 // Corba C -> Python C (derived from Obj):OK
974 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_32"]->getOutputPort("objc"),
975 _nodeMap["Node_14"]->getInputPort("objc"));
977 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("double"),
978 _nodeMap["Node_13"]->getInputPort("dble"));
980 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("long"),
981 _nodeMap["Node_13"]->getInputPort("lng"));
983 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("str"),
984 _nodeMap["Node_13"]->getInputPort("s"));
986 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_21"]->getOutputPort("obj"),
987 _nodeMap["Node_13"]->getInputPort("ob"));
989 // --- Corba sequence<double> -> Python sequence<double>
990 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_23"]->getOutputPort("dblevec"),
991 _nodeMap["Node_14"]->getInputPort("li"));
993 // --- Corba sequence<sequence<double>> -> Python sequence<sequence<double>>
994 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_29"]->getOutputPort("dblevecvec"),
995 _nodeMap["Node_14"]->getInputPort("lili"));
997 // --- Corba sequence<object> -> Python sequence<object>
998 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_28"]->getOutputPort("objvec"),
999 _nodeMap["Node_14"]->getInputPort("lobj"));
1001 // --- Corba sequence<string> -> Python sequence<string>
1002 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_27"]->getOutputPort("strvec"),
1003 _nodeMap["Node_14"]->getInputPort("lstr"));
1005 // --- Corba sequence<object> -> Python sequence<object>
1006 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_30"]->getOutputPort("objvecvec"),
1007 _nodeMap["Node_14"]->getInputPort("llobj"));
1009 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
1010 _nodeMap["Node_15"]->getInputPort("lngvec"));
1012 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_31"]->getOutputPort("lngvec"),
1013 _nodeMap["Node_15"]->getInputPort("dblevec"));
1017 void RuntimeTest::createDataLinksXML()
1019 DEBTRACE(" --- create data links, xml nodes" );
1021 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
1022 _nodeMap["Node_36"]->getInputPort("dblevec")),
1023 YACS::ENGINE::ConversionException);
1025 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
1026 _nodeMap["Node_36"]->getInputPort("dble")),
1027 YACS::ENGINE::ConversionException);
1029 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1030 _nodeMap["Node_33"]->getInputPort("dble")),
1031 YACS::ENGINE::ConversionException);
1033 CPPUNIT_ASSERT_THROW(_blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1034 _nodeMap["Node_34"]->getInputPort("dblevec")),
1035 YACS::ENGINE::ConversionException);
1037 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_16"]->getOutputPort("c"),
1038 _nodeMap["Node_36"]->getInputPort("dble"));
1040 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_26"]->getOutputPort("dblevec"),
1041 _nodeMap["Node_36"]->getInputPort("dblevec"));
1043 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_29"]->getOutputPort("dblevecvec"),
1044 _nodeMap["Node_36"]->getInputPort("dblevecvec"));
1046 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dble"),
1047 _nodeMap["Node_33"]->getInputPort("dble"));
1049 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevec"),
1050 _nodeMap["Node_34"]->getInputPort("dblevec"));
1052 _blocMap["Bloc_3"]->edAddLink(_nodeMap["Node_36"]->getOutputPort("dblevecvec"),
1053 _nodeMap["Node_35"]->getInputPort("dblevecvec"));
1057 void RuntimeTest::manualInitInputPort()
1059 DEBTRACE(" --- InputPort initialization" );
1062 CPPUNIT_ASSERT(! _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
1063 set<InputPort *> unitialized = _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
1064 DEBTRACE(unitialized.size());
1065 for (set<InputPort *>::const_iterator iter = unitialized.begin(); iter != unitialized.end(); iter++)
1067 DEBTRACE(_blocMap["Bloc_3"]->getInPortName(*iter));
1070 _nodeMap["Node_10"]->getInputPort("a")->edInit(10.51);
1072 // CORBA::Any anyLong;
1073 // anyLong <<= (CORBA::Long) 1;
1075 _nodeMap["Node_20"]->getInputPort("long")->edInit(1);
1078 // --- manual set of a linked input port: no use under normal conditions
1079 // (value will be replaced by output value before activation and read)
1082 aString <<= (const char *)"texte";
1083 _nodeMap["Node_20"]->getInputPort("str")->put(&aString);
1084 // _nodeMap["Node_20"]->getInputPort("str")->edInit("texte");
1088 set<InputPort *> unitialized = _blocMap["Bloc_3"]->edGetSetOfUnitializedInputPort();
1089 DEBTRACE(unitialized.size());
1090 CPPUNIT_ASSERT( _blocMap["Bloc_3"]->edAreAllInputPortInitialized() );
1099 DEBTRACE("Python input port double");
1100 InputPort* inport=_nodeMap["Node_10"]->getInputPort("a");
1102 DEBTRACE("Initialize port with C++ double value");
1103 a = AtomAny::New(d);
1104 inport->edInit("Cpp",a);
1106 pyob=((InputPyPort*)inport)->getPyObj();
1107 DEBTRACE(pyob->ob_refcnt);
1108 CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1110 DEBTRACE("Initialize port with XML double value");
1111 inport->edInit("XML","<value><double>10.51</double></value>");
1112 pyob=((InputPyPort*)inport)->getPyObj();
1113 DEBTRACE(pyob->ob_refcnt);
1114 CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1116 DEBTRACE("Initialize port with XML int value");
1117 inport->edInit("XML","<value><int>10</int></value>");
1118 pyob=((InputPyPort*)inport)->getPyObj();
1119 DEBTRACE(pyob->ob_refcnt);
1120 CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == 10.);
1122 DEBTRACE("Initialize port with Python double value");
1123 PyGILState_STATE gstate = PyGILState_Ensure();
1124 inport->edInit("Python",PyFloat_FromDouble(d));
1125 PyGILState_Release(gstate);
1126 pyob=((InputPyPort*)inport)->getPyObj();
1127 DEBTRACE(pyob->ob_refcnt);
1128 CPPUNIT_ASSERT(PyFloat_AS_DOUBLE(pyob) == d);
1130 DEBTRACE("Python input port seq<double>");
1131 inport=_nodeMap["Node_14"]->getInputPort("li");
1132 DEBTRACE("Initialize port with XML seq<double> value");
1133 inport->edInit("XML","<value><array><data>\
1134 <value><double>1.5</double></value>\
1135 <value><double>2.4</double></value>\
1136 </data></array></value>");
1137 pyob=((InputPyPort*)inport)->getPyObj();
1138 DEBTRACE(pyob->ob_refcnt);
1140 DEBTRACE("Initialize port with XML seq<int> value");
1141 inport->edInit("XML","<value><array><data>\
1142 <value><int>15</int></value>\
1143 <value><int>24</int></value>\
1144 </data></array></value>");
1145 pyob=((InputPyPort*)inport)->getPyObj();
1146 DEBTRACE(pyob->ob_refcnt);
1148 DEBTRACE("CORBA input port int");
1149 inport=_nodeMap["Node_20"]->getInputPort("long");
1150 DEBTRACE("Initialize port with XML int value");
1151 inport->edInit("XML","<value><int>10</int></value>");
1152 any=((InputCorbaPort*)inport)->getAny();
1156 DEBTRACE("l = " << l);
1157 CPPUNIT_ASSERT(l == 10);
1159 DEBTRACE("CORBA input port double");
1160 inport=_nodeMap["Node_17"]->getInputPort("b");
1161 DEBTRACE("Initialize port with XML double value");
1162 inport->edInit("XML","<value><double>10.51</double></value>");
1163 any=((InputCorbaPort*)inport)->getAny();
1165 CPPUNIT_ASSERT_DOUBLES_EQUAL(10.51,d, 1e-12);
1167 DEBTRACE("CORBA input port seq<double>");
1168 inport=_nodeMap["Node_24"]->getInputPort("dblevec");
1169 DEBTRACE("Initialize port with XML seq<double> value");
1170 inport->edInit("XML","<value><array><data>\
1171 <value><double>1.5</double></value>\
1172 <value><double>2.4</double></value>\
1173 </data></array></value>");
1178 void RuntimeTest::manualExecuteNoThread()
1180 DEBTRACE(" --- execution Python Node_10" );
1181 ((ElementaryNode*)_nodeMap["Node_10"])->load();
1182 ((ElementaryNode*)_nodeMap["Node_10"])->execute();
1183 // CPPUNIT_ASSERT_DOUBLES_EQUAL(10.51, (ElementaryNode*)_nodeMap["Node_10"])
1184 DEBTRACE(" --- execution Python Node_11" );
1185 ((ElementaryNode*)_nodeMap["Node_11"])->load();
1186 ((ElementaryNode*)_nodeMap["Node_11"])->execute();
1188 DEBTRACE(" --- execution Python Node_12" );
1189 ((ElementaryNode*)_nodeMap["Node_12"])->load();
1190 ((ElementaryNode*)_nodeMap["Node_12"])->execute();
1192 DEBTRACE(" --- execution CORBA Node_16" );
1193 ((ElementaryNode*)_nodeMap["Node_16"])->load();
1194 ((ElementaryNode*)_nodeMap["Node_16"])->execute();
1196 DEBTRACE(" --- execution CORBA Node_17" );
1197 ((ElementaryNode*)_nodeMap["Node_17"])->load();
1198 ((ElementaryNode*)_nodeMap["Node_17"])->execute();
1200 DEBTRACE(" --- execution CORBA Node_18" );
1201 ((ElementaryNode*)_nodeMap["Node_18"])->load();
1202 ((ElementaryNode*)_nodeMap["Node_18"])->execute();
1204 DEBTRACE(" --- execution CORBA Node_19" );
1205 ((ElementaryNode*)_nodeMap["Node_19"])->load();
1206 ((ElementaryNode*)_nodeMap["Node_19"])->execute();
1208 DEBTRACE(" --- execution CORBA Node_20" );
1209 ((ElementaryNode*)_nodeMap["Node_20"])->load();
1210 ((ElementaryNode*)_nodeMap["Node_20"])->execute();
1212 DEBTRACE(" --- execution CORBA Node_21" );
1213 ((ElementaryNode*)_nodeMap["Node_21"])->load();
1214 ((ElementaryNode*)_nodeMap["Node_21"])->execute();
1216 DEBTRACE(" --- execution CORBA Node_29" );
1217 ((ElementaryNode*)_nodeMap["Node_29"])->load();
1218 ((ElementaryNode*)_nodeMap["Node_29"])->execute();
1220 DEBTRACE(" --- execution Python Node_13" );
1221 ((ElementaryNode*)_nodeMap["Node_13"])->load();
1222 ((ElementaryNode*)_nodeMap["Node_13"])->execute();
1224 DEBTRACE(" --- execution CORBA Node_22" );
1225 ((ElementaryNode*)_nodeMap["Node_22"])->load();
1226 ((ElementaryNode*)_nodeMap["Node_22"])->execute();
1228 DEBTRACE(" --- execution CORBA Node_23" );
1229 ((ElementaryNode*)_nodeMap["Node_23"])->load();
1230 ((ElementaryNode*)_nodeMap["Node_23"])->execute();
1232 DEBTRACE(" --- execution CORBA Node_24" );
1233 ((ElementaryNode*)_nodeMap["Node_24"])->load();
1234 ((ElementaryNode*)_nodeMap["Node_24"])->execute();
1236 DEBTRACE(" --- execution CORBA Node_27" );
1237 ((ElementaryNode*)_nodeMap["Node_27"])->load();
1238 ((ElementaryNode*)_nodeMap["Node_27"])->execute();
1240 DEBTRACE(" --- execution CORBA Node_28" );
1241 ((ElementaryNode*)_nodeMap["Node_28"])->load();
1242 ((ElementaryNode*)_nodeMap["Node_28"])->execute();
1244 DEBTRACE(" --- execution CORBA Node_30" );
1245 ((ElementaryNode*)_nodeMap["Node_30"])->load();
1246 ((ElementaryNode*)_nodeMap["Node_30"])->execute();
1248 DEBTRACE(" --- execution CORBA Node_32" );
1249 ((ElementaryNode*)_nodeMap["Node_32"])->load();
1250 ((ElementaryNode*)_nodeMap["Node_32"])->execute();
1252 DEBTRACE(" --- execution CORBA Node_26" );
1253 ((ElementaryNode*)_nodeMap["Node_26"])->load();
1254 ((ElementaryNode*)_nodeMap["Node_26"])->execute();
1256 DEBTRACE(" --- execution CORBA Node_31" );
1257 ((ElementaryNode*)_nodeMap["Node_31"])->load();
1258 ((ElementaryNode*)_nodeMap["Node_31"])->execute();
1260 DEBTRACE(" --- execution Python Node_14" );
1261 ((ElementaryNode*)_nodeMap["Node_14"])->load();
1262 ((ElementaryNode*)_nodeMap["Node_14"])->execute();
1264 DEBTRACE(" --- execution Python Node_15" );
1265 ((ElementaryNode*)_nodeMap["Node_15"])->load();
1266 ((ElementaryNode*)_nodeMap["Node_15"])->execute();
1268 std::cerr << __LINE__ << std::endl;
1269 DEBTRACE(" --- execution XML Node_36" );
1270 ((ElementaryNode*)_nodeMap["Node_36"])->load();
1271 ((ElementaryNode*)_nodeMap["Node_36"])->execute();
1273 DEBTRACE(" --- execution CORBA Node_33" );
1274 ((ElementaryNode*)_nodeMap["Node_33"])->load();
1275 ((ElementaryNode*)_nodeMap["Node_33"])->execute();
1277 DEBTRACE(" --- execution CORBA Node_34" );
1278 ((ElementaryNode*)_nodeMap["Node_34"])->load();
1279 ((ElementaryNode*)_nodeMap["Node_34"])->execute();
1281 DEBTRACE(" --- execution CORBA Node_35" );
1282 ((ElementaryNode*)_nodeMap["Node_35"])->load();
1283 ((ElementaryNode*)_nodeMap["Node_35"])->execute();
1285 DEBTRACE(" --- end of execution" );
1289 void RuntimeTest::manualGetOutputs()
1294 PyObject *ob=((OutputPyPort*)_nodeMap["Node_11"]->getOutputPort("c"))->get();
1295 DEBTRACE("ob refcnt: " << ob->ob_refcnt);
1296 std::cerr << "Output port Node_11.c: ";
1297 PyGILState_STATE gstate = PyGILState_Ensure();
1298 PyObject_Print(ob,stderr,Py_PRINT_RAW);
1299 PyGILState_Release(gstate);
1300 std::cerr << std::endl;
1302 // DEBTRACE("a: " << &a);
1303 // DEBTRACE("a.value(): " << a.value());
1305 x= ((InputCorbaPort*)_nodeMap["Node_16"]->getInputPort("a"))->getAny();
1306 DEBTRACE("CORBA Node_16 input a any: " << x);
1308 DEBTRACE("CORBA Node_16 input a double: " << l);
1310 *((InputCorbaPort*)_nodeMap["Node_17"]->getInputPort("b"))->getAny() >>= l;
1311 DEBTRACE("CORBA Node_17 input b double: " << l);
1313 *((InputCorbaPort*)_nodeMap["Node_18"]->getInputPort("b"))->getAny() >>= l;
1314 DEBTRACE("CORBA Node_18 input a double: " << l);
1316 *((OutputCorbaPort*)_nodeMap["Node_16"]->getOutputPort("c"))->getAny() >>= l;
1317 DEBTRACE("CORBA Node_16 output c double: " << l);
1319 *((OutputCorbaPort*)_nodeMap["Node_17"]->getOutputPort("c"))->getAny() >>= l;
1320 DEBTRACE("CORBA Node_17 output c double: " << l);
1322 *((OutputCorbaPort*)_nodeMap["Node_18"]->getOutputPort("c"))->getAny() >>= l;
1323 DEBTRACE("CORBA Node_18 output c double: " << l);
1325 DEBTRACE(" --- fini" );
1328 void RuntimeTest::createCppNodes()
1331 string s = "Node_Cpp";
1332 ElementaryNode* node = _myRuntime->createCompoNode("Cpp",s);
1334 InputPort *i1 = node->edAddInputPort("id1", _tc_double);
1335 InputPort *i2 = node->edAddInputPort("ii2", _tc_int);
1337 OutputPort *o3 = node->edAddOutputPort("os3", _tc_string);
1339 CPPUNIT_ASSERT_EQUAL(node->getImplementation(),string("Cpp"));
1340 CPPUNIT_ASSERT_EQUAL(node->getNumberOfInputPorts(),2);
1341 CPPUNIT_ASSERT_EQUAL(node->getNumberOfOutputPorts(),1);
1342 CPPUNIT_ASSERT_EQUAL(node->getInPortName(i1),string("id1"));
1343 CPPUNIT_ASSERT_EQUAL(node->getOutPortName(o3),string("os3"));
1345 CPPUNIT_ASSERT_EQUAL(node->getInputPort("id1"),i1);
1346 CPPUNIT_ASSERT_EQUAL(node->getOutputPort("os3"),o3);
1351 void RuntimeTest::convertPorts()
1353 const char *type[] = { "Cpp", "CORBA", "Python", "XML" };
1354 int itype, jtype, ntypes = sizeof(type)/sizeof(const char *);
1356 string s0 = "Node_";
1362 for (itype=0; itype<ntypes-1; itype++)
1364 string s = s0 + type[itype];
1367 DEBTRACE("Node " << type[itype] << " creation");
1368 ElementaryNode* node;
1372 node = _myRuntime->createRefNode(type[itype],s);
1375 node = _myRuntime->createScriptNode(type[itype], s);
1378 node = _myRuntime->createRefNode("xmlsh",s);
1381 node = _myRuntime->createCompoNode(type[itype], s);
1384 InputPort *inport = node->edAddInputPort("id1", _tc_double);
1385 CPPUNIT_ASSERT(NULL != node);
1386 for (jtype=0; jtype < ntypes; jtype++)
1388 double d0= itype * 10 + jtype, d1;
1389 InputPort* pwrap=_myRuntime->adapt(inport, type[jtype], _tc_double);
1396 v = vAny = AtomAny::New(d0);
1400 cAny <<= (CORBA::Double) d0;
1403 v = pAny = PyFloat_FromDouble(d0);
1408 os << "<value><double>" << d0 << "</double></value>";
1418 if ((itype == 2) && (jtype == 2))
1420 std::cerr << "s = " << s << endl;
1423 DEBTRACE("Put a " << type[jtype] << " double (" << d0 << ") in " << s);
1426 PyGILState_STATE gstate = PyGILState_Ensure();
1428 PyGILState_Release(gstate);
1439 Any * a=((InputCppPort*)inport)->getCppObj();
1440 CPPUNIT_ASSERT(a->getType()->isA(_tc_double));
1441 d1 = a->getDoubleValue();
1446 CORBA::Any * a = ((InputCorbaPort*)inport)->getAny();
1447 CPPUNIT_ASSERT(a->type()->equal(CORBA::_tc_double));
1455 PyObject *a = ((InputPyPort*)inport)->getPyObj();
1456 CPPUNIT_ASSERT(PyFloat_Check(a));
1457 d1 = PyFloat_AsDouble(a);
1462 const char *a = ((InputXmlPort*)inport)->getXml();
1463 const char *a1, *a2, *a3, *a_end;
1464 a_end = a + strlen(a) - 1;
1465 while (isspace(*a_end)) a_end--;
1467 a2 = a + strlen("<value><double>");
1468 a3 = a_end - strlen("</double></value>") + 1;
1469 CPPUNIT_ASSERT(!strncmp(a1, "<value><double>", strlen("<value><double>")));
1470 CPPUNIT_ASSERT(!strncmp(a3, "</double></value>", strlen("</double></value>")));
1472 d1 = strtod(a2, &err);
1473 CPPUNIT_ASSERT(err == a3);
1478 CPPUNIT_ASSERT_DOUBLES_EQUAL(d0, d1, 1e-12);
1492 if (pwrap != inport) delete pwrap;
1498 void myTestRun(int nIn, int nOut, Any **In, Any **Out)
1501 cerr << "myTestRun nIn = " << nIn << endl;
1502 cerr << "myTestRun nOut = " << nOut << endl;
1504 x = In[0]->getDoubleValue();
1509 Out[0] = AtomAny::New(y);
1513 throw YACS::Exception("myTestRun : input must be a positive or null real");
1518 void RuntimeTest::executeCppNode()
1520 cerr << endl << endl;
1525 DEBTRACE("execute a CppNode with an internal C++ implementation")
1526 ServiceNode * node = _myRuntime->createCompoNode("Cpp", "test");
1527 ((CppNode *) node)->setFunc(myTestRun);
1529 InputPort *in = node->edAddInputPort("in", _tc_double);
1530 OutputPort *out = node->edAddOutputPort("out", _tc_double);
1534 v = AtomAny::New(dv);
1535 in->edInit("Cpp",v);
1539 w = ((OutputCppPort *) out)->get();
1540 dw = w->getDoubleValue();
1542 cerr << "sqrt(" << dv << ") = " << dw << endl;
1543 CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1545 u = AtomAny::New((double) -3.5);
1546 in->edInit("Cpp",u);
1547 CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1554 DEBTRACE("execute a CppNode with an external C++ implementation (in a dynamic library)");
1556 node = _myRuntime->createCompoNode("Cpp", "test");
1557 CppComponent * C = new CppComponent("TestComponent");
1558 node->setComponent(C);
1560 node->setMethod("f");
1562 in = node->edAddInputPort("in", _tc_double);
1563 out = node->edAddOutputPort("out", _tc_double);
1567 v = AtomAny::New(dv);
1568 in->edInit("Cpp",v);
1572 w = ((OutputCppPort *) out)->get();
1573 dw = w->getDoubleValue();
1575 cerr << "sqrt(" << dv << ") = " << dw << endl;
1576 CPPUNIT_ASSERT_DOUBLES_EQUAL(dw, sqrt(dv), 1e-12);
1578 u = AtomAny::New((double) -3.5);
1579 in->edInit("Cpp",u);
1580 CPPUNIT_ASSERT_THROW(node->execute(), YACS::Exception);
1589 void RuntimeTest::createGraphWithCppNodes()
1591 ElementaryNode * n1, * n2;
1592 InputPort *in1, *in2;
1593 OutputPort *out1, *out2;
1595 n1 = _myRuntime->createCompoNode(CppNode::KIND, "test1");
1596 n2 = _myRuntime->createScriptNode(PythonNode::KIND, "test2");
1598 CppComponent *C = new CppComponent("TestComponent");
1599 ((CppNode *) n1)->setComponent(C);
1601 ((CppNode *) n1)->setMethod("f");
1602 in1 = n1->edAddInputPort("i", _tc_double);
1603 out1 = n1->edAddOutputPort("o", _tc_double);
1605 ((InlineNode*) n2)->setScript("a=a+1\n");
1606 in2 = n2->edAddInputPort("a", _tc_double);
1607 out2 = n2->edAddOutputPort("a", _tc_double);
1609 Bloc * loopBody = _myRuntime->createBloc("LoopBody");
1610 loopBody->edAddChild(n1);
1611 loopBody->edAddChild(n2);
1612 loopBody->edAddLink(out1, in2);
1613 loopBody->edAddLink(out2, in1);
1615 ForLoop *loop=_myRuntime->createForLoop("Loop");
1616 loop->edSetNode(loopBody);
1617 InputPort *iNbTimes=loop->edGetNbOfTimesInputPort();
1618 iNbTimes->edInit(5);
1620 Bloc * graph = _myRuntime->createBloc("graph");
1621 graph->edAddChild(loop);
1623 DEBTRACE("n1->getInputPort(\"in\") = " << n1->getInputPort("i")->getName())
1631 DEBTRACE(out2->dump());
1636 void RuntimeTest::classTeardown()
1638 if (endTests) return;
1642 delete _blocMap["Bloc_3"];
1643 delete _blocMap["Bloc_2"];
1644 delete _nodeMap["Node_4"];
1645 delete _nodeMap["Node_5"];
1646 delete _nodeMap["Node_6"];
1647 delete _nodeMap["Node_7"];
1648 delete _nodeMap["Node_8"];
1649 delete _nodeMap["Node_9"];
1651 _tc_seqC->decrRef();
1653 list<TypeCodeObjref *>::iterator i;
1654 for (i=_ltc.begin(); i != _ltc.end(); i++)
1657 _tc_seqseqobj->decrRef();
1658 _tc_seqobj->decrRef();
1662 _tc_seqseqdble->decrRef();
1663 _tc_seqdble->decrRef();
1664 _tc_seqstr->decrRef();
1665 _tc_seqlong->decrRef();
1666 _tc_string->decrRef();