1 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
4 #include "ElementaryNode.hxx"
7 #include "RuntimeSALOME.hxx"
9 #include "PythonNode.hxx"
10 #include "CORBANode.hxx"
11 #include "XMLNode.hxx"
12 #include "TypeConversions.hxx"
13 #include "CORBACORBAConv.hxx"
14 #include "PythonCORBAConv.hxx"
15 #include "CORBAPythonConv.hxx"
16 #include "CORBAXMLConv.hxx"
18 #include "runtimeTest.hxx"
20 #include <omniORB4/CORBA.h>
29 using namespace YACS::ENGINE;
35 #define MYDEBTRACE {std::cerr << __FILE__ << " [" << __LINE__ << "] : ";}
36 #define DEBTRACE(msg) {MYDEBTRACE; std::cerr<<msg<<std::endl<<std::flush;}
43 void RuntimeTest::setUp()
47 void RuntimeTest::tearDown()
51 void RuntimeTest::test1()
55 RuntimeSALOME::setRuntime();
57 Runtime *myRuntime = getRuntime();
61 TypeCode *tc_double = new TypeCode(Double);
62 TypeCode *tc_int = new TypeCode(Int);
63 TypeCode *tc_string = new TypeCode(String);
64 TypeCode *tc = TypeCode::interface_tc("id","name");
65 TypeCode *tc_obj = TypeCode::interface_tc("eo:Obj","Obj");
66 DEBTRACE( " " << tc->id() << " " << tc->name() );
67 TypeCode *tc_seqdble = TypeCode::sequence_tc("eo:seqdouble","seqdouble",tc_double);
68 TypeCode *tc_seqstr = TypeCode::sequence_tc("eo:seqstring","seqstring",tc_string);
69 TypeCode *tc_seqlong = TypeCode::sequence_tc("eo:seqlong","seqlong",tc_int);
70 TypeCode *tc_seqobj = TypeCode::sequence_tc("eo:seqobj","seqobj",tc_obj);
71 TypeCode *tc_seqseqdble= TypeCode::sequence_tc("eo:seqseqdble","seqseqdble",tc_seqdble);
72 TypeCode *tc_seqseqobj = TypeCode::sequence_tc("eo:seqseqobj","seqseqobj",tc_seqobj);
73 std::list<TypeCode_objref *> ltc;
74 ltc.push_back((TypeCode_objref *)tc_obj);
75 TypeCode *tc_C = TypeCode::interface_tc("eo:C","C",ltc);
76 TypeCode *tc_seqC = TypeCode::sequence_tc("eo:seqC","seqC",tc_C);
78 DEBTRACE("int is a int: "); CPPUNIT_ASSERT( tc_int->is_a(tc_int));
79 DEBTRACE("seqdble is not a seqlong: "); CPPUNIT_ASSERT(!tc_seqdble->is_a(tc_seqlong));
80 DEBTRACE("seqdble is a seqdble: "); CPPUNIT_ASSERT( tc_seqdble->is_a(tc_seqdble));
81 DEBTRACE("seqlong is not a seqdble: "); CPPUNIT_ASSERT(!tc_seqlong->is_a(tc_seqdble));
82 DEBTRACE("C is a Obj: "); CPPUNIT_ASSERT( tc_C->is_a(tc_obj));
83 DEBTRACE("Obj is not a C: " ); CPPUNIT_ASSERT(!tc_obj->is_a(tc_C));
84 DEBTRACE("seqC is a seqObj: "); CPPUNIT_ASSERT( tc_seqC->is_a(tc_seqobj));
85 DEBTRACE( "seqObj is not a seqC: "); CPPUNIT_ASSERT(!tc_seqobj->is_a(tc_seqC));
87 map<string, Node*> nodeMap;
90 // --- Nodes 0 a 4 : Python
92 for (int i=0; i<5; i++)
95 ss << "Node_" << inode++;
97 ElementaryNode* node = myRuntime->createNode("Python",s);
99 InputPort *i1 = node->edAddInputPort("id1", tc_double);
100 InputPort *i2 = node->edAddInputPort("ii2", tc_int);
101 InputPort *i3 = node->edAddInputPort("is3", tc_string);
102 InputPort *i4 = node->edAddInputPort("io4", tc_obj);
103 InputPort *i5 = node->edAddInputPort("isd5", tc_seqdble);
104 InputPort *i6 = node->edAddInputPort("isl6", tc_seqlong);
105 InputPort *i7 = node->edAddInputPort("iso7", tc_seqobj);
106 InputPort *i8 = node->edAddInputPort("issd8",tc_seqseqdble);
107 InputPort *i9 = node->edAddInputPort("isso9",tc_seqseqobj);
108 InputPort *i10 = node->edAddInputPort("iC10", tc_C);
109 InputPort *i11 = node->edAddInputPort("isC11",tc_seqC);
111 OutputPort *o1 = node->edAddOutputPort("od1", tc_double);
112 OutputPort *o2 = node->edAddOutputPort("oi2", tc_int);
113 OutputPort *o3 = node->edAddOutputPort("os3", tc_string);
114 OutputPort *o4 = node->edAddOutputPort("oo4", tc_obj);
115 OutputPort *o5 = node->edAddOutputPort("osd5", tc_seqdble);
116 OutputPort *o6 = node->edAddOutputPort("osl6", tc_seqlong);
117 OutputPort *o7 = node->edAddOutputPort("oso7", tc_seqobj);
118 OutputPort *o8 = node->edAddOutputPort("ossd8",tc_seqseqdble);
119 OutputPort *o9 = node->edAddOutputPort("osso9",tc_seqseqobj);
120 OutputPort *o10 = node->edAddOutputPort("oC10", tc_C);
121 OutputPort *o11 = node->edAddOutputPort("osC11",tc_seqC);
124 // --- Nodes 5 a 9 : CORBA
126 for (int i=5; i<10; i++)
129 ss << "Node_" << inode++;
131 ElementaryNode* node = myRuntime->createNode("CORBA",s);
133 InputPort *i1 = node->edAddInputPort("id1", tc_double);
134 InputPort *i2 = node->edAddInputPort("ii2", tc_int);
135 InputPort *i3 = node->edAddInputPort("is3", tc_string);
136 InputPort *i4 = node->edAddInputPort("io4", tc_obj);
137 InputPort *i5 = node->edAddInputPort("isd5", tc_seqdble);
138 InputPort *i6 = node->edAddInputPort("isl6", tc_seqlong);
139 InputPort *i7 = node->edAddInputPort("iso7", tc_seqobj);
140 InputPort *i8 = node->edAddInputPort("issd8",tc_seqseqdble);
141 InputPort *i9 = node->edAddInputPort("isso9",tc_seqseqobj);
142 InputPort *i10 = node->edAddInputPort("iC10", tc_C);
143 InputPort *i11 = node->edAddInputPort("isC11",tc_seqC);
145 OutputPort *o1 = node->edAddOutputPort("od1", tc_double);
146 OutputPort *o2 = node->edAddOutputPort("oi2", tc_int);
147 OutputPort *o3 = node->edAddOutputPort("os3", tc_string);
148 OutputPort *o4 = node->edAddOutputPort("oo4", tc_obj);
149 OutputPort *o5 = node->edAddOutputPort("osd5", tc_seqdble);
150 OutputPort *o6 = node->edAddOutputPort("osl6", tc_seqlong);
151 OutputPort *o7 = node->edAddOutputPort("oso7", tc_seqobj);
152 OutputPort *o8 = node->edAddOutputPort("ossd8",tc_seqseqdble);
153 OutputPort *o9 = node->edAddOutputPort("osso9",tc_seqseqobj);
154 OutputPort *o10 = node->edAddOutputPort("oC10", tc_C);
155 OutputPort *o11 = node->edAddOutputPort("osC11",tc_seqC);
158 DEBTRACE(" --- create bloc, add two nodes, check constituants" );
160 map<string, Bloc*> blocMap;
163 // --- Bloc_0 with Node_0 and Node_1
166 ss << "Bloc_" << ibloc++;
168 Bloc* bloc = new Bloc(s);
171 bloc->edAddChild(nodeMap["Node_0"]);
172 bloc->edAddChild(nodeMap["Node_1"]);
174 set<ElementaryNode *> setelem = bloc->getRecursiveConstituents();
175 CPPUNIT_ASSERT(setelem.size() == 2);
179 // --- Bloc_1 with Node_2
182 ss << "Bloc_" << ibloc++;
184 Bloc* bloc = new Bloc(s);
187 bloc->edAddChild(nodeMap["Node_2"]);
190 DEBTRACE(" --- add a node already used in the bloc does nothing (return false)" );
191 CPPUNIT_ASSERT( ! blocMap["Bloc_0"]->edAddChild(nodeMap["Node_1"]));
193 DEBTRACE(" --- add a node already used elsewhere raises exception " );
194 CPPUNIT_ASSERT_THROW(blocMap["Bloc_1"]->edAddChild(nodeMap["Node_1"]),
198 DEBTRACE(" --- recursive blocs, check constituants" );
200 // --- Bloc_2 with Bloc_1 and Bloc_2
203 ss << "Bloc_" << ibloc++;
205 Bloc* bloc = new Bloc(s);
208 bloc->edAddChild(nodeMap["Bloc_0"]); // 2 elementary nodes
209 bloc->edAddChild(nodeMap["Bloc_1"]); // 1 elementary node
210 bloc->edAddChild(nodeMap["Node_3"]); // 1 elementary node
214 set<ElementaryNode *> setelem = blocMap["Bloc_2"]->getRecursiveConstituents();
215 CPPUNIT_ASSERT(setelem.size() == 4);
216 for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
218 DEBTRACE(" elem name = " << (*it)->getName());
223 DEBTRACE(" --- create and delete data links" );
225 CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
226 CPPUNIT_ASSERT_THROW(blocMap["Bloc_0"]->edAddLink(nodeMap["Node_0"]->getOutputPort("od1"),
227 nodeMap["Node_1"]->getInputPort("is3")),
228 YACS::ENGINE::ConversionException);
229 CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
231 blocMap["Bloc_0"]->edAddLink(nodeMap["Node_0"]->getOutputPort("oi2"),
232 nodeMap["Node_1"]->getInputPort("ii2"));
233 CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 21);
235 blocMap["Bloc_0"]->edRemoveLink(nodeMap["Node_0"]->getOutputPort("oi2"),
236 nodeMap["Node_1"]->getInputPort("ii2"));
237 CPPUNIT_ASSERT(blocMap["Bloc_0"]->getNumberOfInputPorts() == 22);
240 DEBTRACE(" --- create python nodes with scripts" );
242 // --- Node 10 : Python
246 ss << "Node_" << inode++;
248 ElementaryNode* node = myRuntime->createNode("Python",s);
250 ((PythonNode*) node)->set_script("a=a+1\n");
251 InputPort *i1 = node->edAddInputPort("a", tc_double);
252 OutputPort *o1 = node->edAddOutputPort("a", tc_double);
255 // --- Node 11 : Python
259 ss << "Node_" << inode++;
261 ElementaryNode* node = myRuntime->createNode("Python",s);
263 ((PythonNode*) node)->set_script("a=b+1\n"
267 "seqdble=[1.5,2.4]\n"
269 "dblevecvec=[[1.5,2.4],[6.7,7.8]]\n"
271 InputPort *i1 = node->edAddInputPort("b", tc_double);
272 OutputPort *o1 = node->edAddOutputPort("c", tc_double);
273 OutputPort *o2 = node->edAddOutputPort("i", tc_int);
274 OutputPort *o3 = node->edAddOutputPort("s", tc_string);
275 OutputPort *o4 = node->edAddOutputPort("seqdble", tc_seqdble);
276 OutputPort *o5 = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
277 OutputPort *o6 = node->edAddOutputPort("lngvec", tc_seqlong);
280 // --- Node 12 : Python
284 ss << "Node_" << inode++;
286 ElementaryNode* node = myRuntime->createNode("Python",s);
288 ((PythonNode*) node)->set_script("a=dble+1\n"
291 InputPort *i1 = node->edAddInputPort("dble", tc_double);
292 OutputPort *o1 = node->edAddOutputPort("dble", tc_double);
295 // --- Node 13 : Python
299 ss << "Node_" << inode++;
301 ElementaryNode* node = myRuntime->createNode("Python",s);
303 ((PythonNode*) node)->set_script("print 'node 13'\n"
306 "o=ob._narrow(eo.Obj)\n"
308 "print o.echoLong(13)\n"
312 "print '++++++++',s,'+++++++++++++'\n"
314 "seqstr=['aaa','bbb']\n"
316 "seqseqobj=[[o,o],[o,o]]\n"
319 InputPort *i1 = node->edAddInputPort("dble", tc_double);
320 InputPort *i2 = node->edAddInputPort("lng", tc_int);
321 InputPort *i3 = node->edAddInputPort("s", tc_string);
322 InputPort *i4 = node->edAddInputPort("ob", tc_obj);
323 OutputPort *o1 = node->edAddOutputPort("dble", tc_double);
324 OutputPort *o2 = node->edAddOutputPort("s", tc_string);
325 OutputPort *o3 = node->edAddOutputPort("lng", tc_int);
326 OutputPort *o4 = node->edAddOutputPort("ob", tc_obj);
327 OutputPort *o5 = node->edAddOutputPort("seqstr", tc_seqstr);
328 OutputPort *o6 = node->edAddOutputPort("seqobj", tc_seqobj);
329 OutputPort *o7 = node->edAddOutputPort("seqseqobj", tc_seqseqobj);
332 // --- Node 14 : Python
336 ss << "Node_" << inode++;
338 ElementaryNode* node = myRuntime->createNode("Python",s);
340 ((PythonNode*) node)->set_script("print li\n"
341 "print 'lili=',lili\n"
342 "print 'lstr=',lstr\n"
343 "print 'lobj=',lobj\n"
344 "print 'llobj=',llobj\n"
345 "print 'objc=',objc\n"
348 InputPort *i1 = node->edAddInputPort("li", tc_seqdble);
349 InputPort *i2 = node->edAddInputPort("lili", tc_seqseqdble);
350 InputPort *i3 = node->edAddInputPort("lstr", tc_seqstr);
351 InputPort *i4 = node->edAddInputPort("lobj", tc_seqobj);
352 InputPort *i5 = node->edAddInputPort("llobj", tc_seqseqobj);
353 InputPort *i6 = node->edAddInputPort("objc", tc_C);
354 OutputPort *o1 = node->edAddOutputPort("li", tc_seqdble);
355 OutputPort *o2 = node->edAddOutputPort("objc", tc_C);
358 // --- Node 15 : Python
362 ss << "Node_" << inode++;
364 ElementaryNode* node = myRuntime->createNode("Python",s);
366 ((PythonNode*) node)->set_script("print li\n"
367 "li=[2*e for e in li]\n"
373 InputPort *i1 = node->edAddInputPort("li", tc_seqdble);
374 InputPort *i2 = node->edAddInputPort("obj", tc_obj);
375 InputPort *i3 = node->edAddInputPort("lngvec", tc_seqlong);
376 InputPort *i4 = node->edAddInputPort("dblevec", tc_seqdble);
377 OutputPort *o1 = node->edAddOutputPort("li", tc_seqdble);
380 DEBTRACE(" --- create CORBA nodes" );
382 // --- Node 16 : CORBA
386 ss << "Node_" << inode++;
388 ElementaryNode* node = myRuntime->createNode("CORBA",s);
390 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
391 ((CORBANode *) node)->set_method("echoDouble");
392 InputPort *i1 = node->edAddInputPort("a", tc_double);
393 OutputPort *o1 = node->edAddOutputPort("c", tc_double);
396 // --- Node 17 - 18 : CORBA
398 for (int i =0; i <2; i++)
401 ss << "Node_" << inode++;
403 ElementaryNode* node = myRuntime->createNode("CORBA",s);
405 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
406 ((CORBANode *) node)->set_method("echoDouble");
407 InputPort *i1 = node->edAddInputPort("b", tc_double);
408 OutputPort *o1 = node->edAddOutputPort("c", tc_double);
411 // --- Node 19 : CORBA
415 ss << "Node_" << inode++;
417 ElementaryNode* node = myRuntime->createNode("CORBA",s);
419 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
420 ((CORBANode *) node)->set_method("createObj");
421 InputPort *i1 = node->edAddInputPort("long", tc_int);
422 OutputPort *o1 = node->edAddOutputPort("obj", tc_obj);
425 // --- Node 20, 21, 22 : CORBA
427 for (int i =0; i <3; i++)
430 ss << "Node_" << inode++;
432 ElementaryNode* node = myRuntime->createNode("CORBA",s);
434 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
435 ((CORBANode *) node)->set_method("echoAll");
436 InputPort *i1 = node->edAddInputPort("double", tc_double);
437 InputPort *i2 = node->edAddInputPort("long", tc_int);
438 InputPort *i3 = node->edAddInputPort("str", tc_string);
439 InputPort *i4 = node->edAddInputPort("obj", tc_obj);
440 OutputPort *o1 = node->edAddOutputPort("double", tc_double);
441 OutputPort *o2 = node->edAddOutputPort("long", tc_int);
442 OutputPort *o3 = node->edAddOutputPort("str", tc_string);
443 OutputPort *o4 = node->edAddOutputPort("obj", tc_obj);
446 // --- Node 23 a 26 : CORBA
448 for (int i =0; i <4; i++)
451 ss << "Node_" << inode++;
453 ElementaryNode* node = myRuntime->createNode("CORBA",s);
455 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
456 ((CORBANode *) node)->set_method("echoDoubleVec");
457 InputPort *i1 = node->edAddInputPort("dblevec", tc_seqdble);
458 OutputPort *o1 = node->edAddOutputPort("dblevec", tc_seqdble);
461 // --- Node 27 : CORBA
465 ss << "Node_" << inode++;
467 ElementaryNode* node = myRuntime->createNode("CORBA",s);
469 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
470 ((CORBANode *) node)->set_method("echoStrVec");
471 InputPort *i1 = node->edAddInputPort("strvec", tc_seqstr);
472 OutputPort *o1 = node->edAddOutputPort("strvec", tc_seqstr);
475 // --- Node 28 : CORBA
479 ss << "Node_" << inode++;
481 ElementaryNode* node = myRuntime->createNode("CORBA",s);
483 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
484 ((CORBANode *) node)->set_method("echoObjectVec");
485 InputPort *i1 = node->edAddInputPort("objvec", tc_seqobj);
486 OutputPort *o1 = node->edAddOutputPort("objvec", tc_seqobj);
489 // --- Node 29 : CORBA
493 ss << "Node_" << inode++;
495 ElementaryNode* node = myRuntime->createNode("CORBA",s);
497 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
498 ((CORBANode *) node)->set_method("echoDoubleVecVec");
499 InputPort *i1 = node->edAddInputPort("dblevecvec", tc_seqseqdble);
500 OutputPort *o1 = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
503 // --- Node 30 : CORBA
507 ss << "Node_" << inode++;
509 ElementaryNode* node = myRuntime->createNode("CORBA",s);
511 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
512 ((CORBANode *) node)->set_method("echoObjectVecVec");
513 InputPort *i1 = node->edAddInputPort("objvecvec", tc_seqseqobj);
514 OutputPort *o1 = node->edAddOutputPort("objvecvec", tc_seqseqobj);
517 // --- Node 31 : CORBA
521 ss << "Node_" << inode++;
523 ElementaryNode* node = myRuntime->createNode("CORBA",s);
525 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
526 ((CORBANode *) node)->set_method("echoIntVec");
527 InputPort *i1 = node->edAddInputPort("lngvec", tc_seqlong);
528 OutputPort *o1 = node->edAddOutputPort("lngvec", tc_seqlong);
531 // --- Node 32 : CORBA
535 ss << "Node_" << inode++;
537 ElementaryNode* node = myRuntime->createNode("CORBA",s);
539 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
540 ((CORBANode *) node)->set_method("createC");
541 OutputPort *o1 = node->edAddOutputPort("objc", tc_C);
544 // --- Node 33 : CORBA
548 ss << "Node_" << inode++;
550 ElementaryNode* node = myRuntime->createNode("CORBA",s);
552 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
553 ((CORBANode *) node)->set_method("echoDouble");
554 InputPort *i1 = node->edAddInputPort("dble", tc_double);
555 OutputPort *o1 = node->edAddOutputPort("dble", tc_double);
558 // --- Node 34 : CORBA
562 ss << "Node_" << inode++;
564 ElementaryNode* node = myRuntime->createNode("CORBA",s);
566 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
567 ((CORBANode *) node)->set_method("echoDoubleVec");
568 InputPort *i1 = node->edAddInputPort("dblevec", tc_seqdble);
569 OutputPort *o1 = node->edAddOutputPort("dblevec", tc_seqdble);
572 // --- Node 35 : CORBA
576 ss << "Node_" << inode++;
578 ElementaryNode* node = myRuntime->createNode("CORBA",s);
580 ((CORBANode *) node)->set_ref("corbaname:rir:#test.my_context/Echo.Object");
581 ((CORBANode *) node)->set_method("echoDoubleVecVec");
582 InputPort *i1 = node->edAddInputPort("dblevecvec", tc_seqseqdble);
583 OutputPort *o1 = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
586 DEBTRACE(" --- create XML nodes" );
592 ss << "Node_" << inode++;
594 ElementaryNode* node = myRuntime->createNode("XML",s);
596 ((XmlNode *) node)->set_script("./xmlrun.sh");
597 InputPort *i1 = node->edAddInputPort("dble", tc_double);
598 InputPort *i2 = node->edAddInputPort("dblevec", tc_seqdble);
599 InputPort *i3 = node->edAddInputPort("dblevecvec", tc_seqseqdble);
600 OutputPort *o1 = node->edAddOutputPort("dble", tc_double);
601 OutputPort *o2 = node->edAddOutputPort("dblevec", tc_seqdble);
602 OutputPort *o3 = node->edAddOutputPort("dblevecvec", tc_seqseqdble);
605 DEBTRACE(" --- create Bloc with all nodes" );
607 // --- Bloc_3 with Node_10 and following
611 ss << "Bloc_" << ibloc++;
613 Bloc* bloc = new Bloc(s);
616 for (int i=10; i<inode; i++)
620 string sn = ssn.str();
622 bloc->edAddChild(nodeMap[sn]);
626 DEBTRACE(" --- create data links, python to python" );
629 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_10"]->getOutputPort("a"),
630 nodeMap["Node_11"]->getInputPort("b"));
633 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_10"]->getOutputPort("a"),
634 nodeMap["Node_12"]->getInputPort("dble"));
636 // Python sequence<double> -> Python sequence<double>
637 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_14"]->getOutputPort("li"),
638 nodeMap["Node_15"]->getInputPort("li"));
640 // Python obj C -> Python obj Obj : OK bon sens
641 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_14"]->getOutputPort("objc"),
642 nodeMap["Node_15"]->getInputPort("obj"));
644 // Python Obj -> Python C (dérivé de Obj) : interdit
645 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
646 nodeMap["Node_14"]->getInputPort("objc")),
647 YACS::ENGINE::ConversionException);
649 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("s"),
650 nodeMap["Node_12"]->getInputPort("dble")),
651 YACS::ENGINE::ConversionException);
653 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
654 nodeMap["Node_12"]->getInputPort("dble")),
655 YACS::ENGINE::ConversionException);
657 DEBTRACE(" --- create data links, python to CORBA" );
660 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("c"),
661 nodeMap["Node_16"]->getInputPort("a"));
664 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("i"),
665 nodeMap["Node_19"]->getInputPort("long"));
668 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("s"),
669 nodeMap["Node_20"]->getInputPort("str"));
671 // seq<long> -> seq<double>
672 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("lngvec"),
673 nodeMap["Node_23"]->getInputPort("dblevec"));
675 // seq<long> -> seq<long>
676 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("lngvec"),
677 nodeMap["Node_31"]->getInputPort("lngvec"));
679 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
680 nodeMap["Node_22"]->getInputPort("obj"));
682 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
683 nodeMap["Node_26"]->getInputPort("dblevec"));
685 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqstr"),
686 nodeMap["Node_27"]->getInputPort("strvec"));
688 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqobj"),
689 nodeMap["Node_28"]->getInputPort("objvec"));
691 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("dblevecvec"),
692 nodeMap["Node_29"]->getInputPort("dblevecvec"));
694 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqseqobj"),
695 nodeMap["Node_30"]->getInputPort("objvecvec"));
697 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("seqdble"),
698 nodeMap["Node_27"]->getInputPort("strvec")),
699 YACS::ENGINE::ConversionException);
701 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("ob"),
702 nodeMap["Node_22"]->getInputPort("str")),
703 YACS::ENGINE::ConversionException);
705 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
706 nodeMap["Node_22"]->getInputPort("str")),
707 YACS::ENGINE::ConversionException);
709 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("lng"),
710 nodeMap["Node_22"]->getInputPort("str")),
711 YACS::ENGINE::ConversionException);
713 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
714 nodeMap["Node_22"]->getInputPort("long")),
715 YACS::ENGINE::ConversionException);
717 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("dble"),
718 nodeMap["Node_24"]->getInputPort("dblevec")),
719 YACS::ENGINE::ConversionException);
721 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_11"]->getOutputPort("dblevecvec"),
722 nodeMap["Node_24"]->getInputPort("dblevec")),
723 YACS::ENGINE::ConversionException);
725 CPPUNIT_ASSERT_THROW(blocMap["Bloc_3"]->edAddLink(nodeMap["Node_13"]->getOutputPort("seqstr"),
726 nodeMap["Node_24"]->getInputPort("dblevec")),
727 YACS::ENGINE::ConversionException);
729 DEBTRACE(" --- create data links, CORBA to CORBA" );
732 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
733 nodeMap["Node_17"]->getInputPort("b"));
736 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
737 nodeMap["Node_18"]->getInputPort("b"));
739 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_19"]->getOutputPort("obj"),
740 nodeMap["Node_20"]->getInputPort("obj"));
742 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_18"]->getOutputPort("c"),
743 nodeMap["Node_20"]->getInputPort("double"));
745 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
746 nodeMap["Node_21"]->getInputPort("double"));
748 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
749 nodeMap["Node_21"]->getInputPort("long"));
751 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("str"),
752 nodeMap["Node_21"]->getInputPort("str"));
754 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("obj"),
755 nodeMap["Node_21"]->getInputPort("obj"));
757 // Corba sequence<double> -> Corba sequence<double>
758 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_23"]->getOutputPort("dblevec"),
759 nodeMap["Node_24"]->getInputPort("dblevec"));
761 // Corba sequence<double> -> Corba sequence<double>
762 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
763 nodeMap["Node_25"]->getInputPort("dblevec"));
766 DEBTRACE(" --- create data links, CORBA to Python" );
769 // Corba C -> Python C (dérivé de Obj):OK
770 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_32"]->getOutputPort("objc"),
771 nodeMap["Node_14"]->getInputPort("objc"));
773 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("double"),
774 nodeMap["Node_13"]->getInputPort("dble"));
776 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("long"),
777 nodeMap["Node_13"]->getInputPort("lng"));
779 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("str"),
780 nodeMap["Node_13"]->getInputPort("s"));
782 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_21"]->getOutputPort("obj"),
783 nodeMap["Node_13"]->getInputPort("ob"));
785 // Corba sequence<double> -> Python sequence<double>
786 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_23"]->getOutputPort("dblevec"),
787 nodeMap["Node_14"]->getInputPort("li"));
789 // Corba sequence<sequence<double>> -> Python sequence<sequence<double>>
790 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_29"]->getOutputPort("dblevecvec"),
791 nodeMap["Node_14"]->getInputPort("lili"));
793 // Corba sequence<object> -> Python sequence<object>
794 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_28"]->getOutputPort("objvec"),
795 nodeMap["Node_14"]->getInputPort("lobj"));
797 // Corba sequence<string> -> Python sequence<string>
798 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_27"]->getOutputPort("strvec"),
799 nodeMap["Node_14"]->getInputPort("lstr"));
801 // Corba sequence<object> -> Python sequence<object>
802 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_30"]->getOutputPort("objvecvec"),
803 nodeMap["Node_14"]->getInputPort("llobj"));
805 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
806 nodeMap["Node_15"]->getInputPort("lngvec"));
808 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_31"]->getOutputPort("lngvec"),
809 nodeMap["Node_15"]->getInputPort("dblevec"));
811 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
812 nodeMap["Node_22"]->getInputPort("double"));
814 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("long"),
815 nodeMap["Node_22"]->getInputPort("long"));
817 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_20"]->getOutputPort("str"),
818 nodeMap["Node_22"]->getInputPort("str"));
820 DEBTRACE(" --- create data links, xml nodes" );
822 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_16"]->getOutputPort("c"),
823 nodeMap["Node_36"]->getInputPort("dble"));
825 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_26"]->getOutputPort("dblevec"),
826 nodeMap["Node_36"]->getInputPort("dblevec"));
828 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_29"]->getOutputPort("dblevecvec"),
829 nodeMap["Node_36"]->getInputPort("dblevecvec"));
831 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dble"),
832 nodeMap["Node_33"]->getInputPort("dble"));
834 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dblevec"),
835 nodeMap["Node_34"]->getInputPort("dblevec"));
837 blocMap["Bloc_3"]->edAddLink(nodeMap["Node_36"]->getOutputPort("dblevecvec"),
838 nodeMap["Node_35"]->getInputPort("dblevecvec"));
840 DEBTRACE(" --- initialization" );
842 PyObject *pyDouble = PyFloat_FromDouble(10.51);
843 nodeMap["Node_10"]->getInputPort("a")->put(pyDouble);
846 a <<= (CORBA::Double) 3.14;
849 anyLong <<= (CORBA::Long) 1;
852 anyLong2 <<= (CORBA::Long) 1;
853 nodeMap["Node_20"]->getInputPort("long")->put(&anyLong2);
856 aString <<= (const char *)"texte";
857 nodeMap["Node_20"]->getInputPort("str")->put(&aString);
860 DEBTRACE(" --- execution Python Node_10" );
861 ((ElementaryNode*)nodeMap["Node_10"])->execute();
863 DEBTRACE(" --- execution Python Node_11" );
864 ((ElementaryNode*)nodeMap["Node_11"])->execute();
866 DEBTRACE(" --- execution Python Node_12" );
867 ((ElementaryNode*)nodeMap["Node_12"])->execute();
869 DEBTRACE(" --- execution CORBA Node_16" );
870 ((ElementaryNode*)nodeMap["Node_16"])->execute();
872 DEBTRACE(" --- execution CORBA Node_17" );
873 ((ElementaryNode*)nodeMap["Node_17"])->execute();
875 DEBTRACE(" --- execution CORBA Node_18" );
876 ((ElementaryNode*)nodeMap["Node_18"])->execute();
878 DEBTRACE(" --- execution CORBA Node_19" );
879 ((ElementaryNode*)nodeMap["Node_19"])->execute();
881 DEBTRACE(" --- execution CORBA Node_20" );
882 ((ElementaryNode*)nodeMap["Node_20"])->execute();
884 DEBTRACE(" --- execution CORBA Node_21" );
885 ((ElementaryNode*)nodeMap["Node_21"])->execute();
887 DEBTRACE(" --- execution CORBA Node_29" );
888 ((ElementaryNode*)nodeMap["Node_29"])->execute();
890 DEBTRACE(" --- execution Python Node_13" );
891 ((ElementaryNode*)nodeMap["Node_13"])->execute();
893 DEBTRACE(" --- execution CORBA Node_22" );
894 ((ElementaryNode*)nodeMap["Node_22"])->execute();
896 DEBTRACE(" --- execution CORBA Node_23" );
897 ((ElementaryNode*)nodeMap["Node_23"])->execute();
899 DEBTRACE(" --- execution CORBA Node_24" );
900 ((ElementaryNode*)nodeMap["Node_24"])->execute();
902 DEBTRACE(" --- execution CORBA Node_27" );
903 ((ElementaryNode*)nodeMap["Node_27"])->execute();
905 DEBTRACE(" --- execution CORBA Node_28" );
906 ((ElementaryNode*)nodeMap["Node_28"])->execute();
908 DEBTRACE(" --- execution CORBA Node_30" );
909 ((ElementaryNode*)nodeMap["Node_30"])->execute();
911 DEBTRACE(" --- execution CORBA Node_32" );
912 ((ElementaryNode*)nodeMap["Node_32"])->execute();
914 DEBTRACE(" --- execution CORBA Node_26" );
915 ((ElementaryNode*)nodeMap["Node_26"])->execute();
917 DEBTRACE(" --- execution CORBA Node_31" );
918 ((ElementaryNode*)nodeMap["Node_31"])->execute();
920 DEBTRACE(" --- execution Python Node_14" );
921 ((ElementaryNode*)nodeMap["Node_14"])->execute();
923 DEBTRACE(" --- execution Python Node_15" );
924 ((ElementaryNode*)nodeMap["Node_15"])->execute();
926 DEBTRACE(" --- execution XML Node_36" );
927 ((ElementaryNode*)nodeMap["Node_36"])->execute();
929 DEBTRACE(" --- execution CORBA Node_33" );
930 ((ElementaryNode*)nodeMap["Node_33"])->execute();
932 DEBTRACE(" --- execution CORBA Node_34" );
933 ((ElementaryNode*)nodeMap["Node_34"])->execute();
935 DEBTRACE(" --- execution CORBA Node_35" );
936 ((ElementaryNode*)nodeMap["Node_35"])->execute();
938 DEBTRACE(" --- end of execution" );
943 PyObject *ob=((OutputPyPort*)nodeMap["Node_11"]->getOutputPort("c"))->get();
944 DEBTRACE("ob refcnt: " << ob->ob_refcnt);
945 PyObject_Print(ob,stdout,Py_PRINT_RAW);
947 DEBTRACE("a: " << &a);
948 DEBTRACE("a.value(): " << a.value());
950 x= ((InputCorbaPort*)nodeMap["Node_16"]->getInputPort("a"))->getAny();
951 DEBTRACE("CORBA Node_16 input a any: " << x);
953 DEBTRACE("CORBA Node_16 input a double: " << l);
955 *((InputCorbaPort*)nodeMap["Node_17"]->getInputPort("b"))->getAny() >>= l;
956 DEBTRACE("CORBA Node_17 input b double: " << l);
958 *((InputCorbaPort*)nodeMap["Node_18"]->getInputPort("b"))->getAny() >>= l;
959 DEBTRACE("CORBA Node_18 input a double: " << l);
961 *((OutputCorbaPort*)nodeMap["Node_16"]->getOutputPort("c"))->getAny() >>= l;
962 DEBTRACE("CORBA Node_16 output c double: " << l);
964 *((OutputCorbaPort*)nodeMap["Node_17"]->getOutputPort("c"))->getAny() >>= l;
965 DEBTRACE("CORBA Node_17 output c double: " << l);
967 *((OutputCorbaPort*)nodeMap["Node_18"]->getOutputPort("c"))->getAny() >>= l;
968 DEBTRACE("CORBA Node_18 output c double: " << l);
970 DEBTRACE(" --- fini" );