src/engine/Test/engineTest.cxx

   1 // Copyright (C) 2006-2019  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
  21 //
  22 #include "Bloc.hxx"
  23 #include "Proc.hxx"
  24 #include "Logger.hxx"
  25 #include "ElementaryNode.hxx"
  26 #include "Loop.hxx"
  27 #include "Switch.hxx"
  28 #include "VisitorSaveState.hxx"
  29 #include "SetOfPoints.hxx"
  30
  31 #include "SharedPtr.hxx"
  32 #include "RuntimeForEngineTest.hxx"
  33
  34 #include "engineTest.hxx"
  35
  36 #include <iostream>
  37 #include <sstream>
  38 #include <string>
  39 #include <list>
  40 #include <vector>
  41 #include <string.h>
  42
  43 //#define _DEVDEBUG_
  44 #include "YacsTrace.hxx"
  45
  46 using namespace YACS::ENGINE;
  47 using namespace YACS;
  48 using namespace std;
  49
  50 map<string, Node*> EngineTest::_nodeMap;
  51 map<string, ComposedNode*> EngineTest::_compoMap;
  52
  53 // --- init typecodes
  54
  55 TypeCode *EngineTest::_tc_bool   = new TypeCode(Bool);
  56 TypeCode *EngineTest::_tc_int    = new TypeCode(Int);
  57 TypeCode *EngineTest::_tc_double = new TypeCode(Double);
  58
  59
  60 void EngineTest::setUp()
  61 {
  62 }
  63
  64 void EngineTest::tearDown()
  65 {
  66 }
  67
  68 void EngineTest::cleanUp()
  69 {
  70   map<string, ComposedNode*>::iterator iter2,iter3;
  71   for(map<string, Node*>::iterator iter=_nodeMap.begin();iter!=_nodeMap.end();iter++)
  72     if((*iter).second->getFather()==0)
  73       delete (*iter).second;
  74 }
  75
  76 void EngineTest::checkGetRuntime()
  77 {
  78   CPPUNIT_ASSERT_THROW(Runtime *myrun = getRuntime(), YACS::Exception);
  79   RuntimeForEngineTest::setRuntime();
  80   Runtime *myrun1 = getRuntime();
  81   CPPUNIT_ASSERT(myrun1);
  82   Runtime *myrun2 = getRuntime();
  83   CPPUNIT_ASSERT_EQUAL(myrun1, myrun2);
  84   }
  85
  86 void toto2(void *t)
  87 {
  88   delete [] (char *)t;
  89 }
  90
  91 void toto3(void *t)
  92 {
  93   delete [] (int *)t;
  94 }
  95
  96 void EngineTest::checkAny1()
  97 {
  98   char *toto=new char[10];
  99   strcpy(toto,"lkjlkj");
 100   Any *tmp=AtomAny::New(toto,toto2);//no copy here
 101   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 102   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 103   tmp->incrRef();
 104   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 105   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 106   tmp->decrRef();
 107   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 108   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
 109   tmp->decrRef();
 110   const char tmp2[]="coucou";
 111   tmp=AtomAny::New((char *)tmp2,0);
 112   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
 113   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
 114   tmp->decrRef();
 115   tmp=AtomAny::New(string("abcdef"));
 116   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
 117   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
 118   tmp->decrRef();
 119   tmp=AtomAny::New("ghijk");
 120   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 121   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 122   tmp->decrRef();
 123   tmp=AtomAny::New((char *)"ghijk");
 124   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 125   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 126   tmp->decrRef();
 127 }
 128
 129 class A7
 130 {
 131 private:
 132   double _d;
 133   int _cnt;
 134 public:
 135   A7(double toto):_d(toto),_cnt(1) { }
 136   static A7 *New(double toto) { return new A7(toto); }
 137   double getToto() const { return _d; }
 138   void setToto(double val) { _d=val; }
 139   void incrRef() { _cnt++; }
 140   void decrRef();
 141 private:
 142   ~A7() { }
 143 };
 144
 145 void A7::decrRef()
 146 {
 147   if(--_cnt==0)
 148     delete this;
 149 }
 150
 151
 152 void checkSharedPtrFct2(const A7& a)
 153 {
 154   a.getToto();
 155 }
 156
 157 void checkSharedPtrFct1(const SharedPtr<A7>& a)
 158 {
 159   checkSharedPtrFct2(a);
 160 }
 161
 162
 163 void EngineTest::checkSharedPtr()
 164 {
 165   SharedPtr<A7> titi=A7::New(5.);
 166   SharedPtr<A7> toto=A7::New(5.1);
 167   SharedPtr<A7> tutu(toto);
 168   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.,titi->getToto(),1e-12);
 169   titi->setToto(7.1);
 170   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.1,titi->getToto(),1e-12);
 171   checkSharedPtrFct2(titi);
 172   checkSharedPtrFct2(toto);
 173   titi=toto;
 174   checkSharedPtrFct2(titi);
 175   checkSharedPtrFct2(tutu);
 176 }
 177
 178 void EngineTest::checkAny2()
 179 {
 180   double tabStack[8]={1.2, 3.4, 5.6, 7.8, 9.0, 2.3, 4.5, 6.7};
 181   double *tabHeap=new double[8];
 182   memcpy(tabHeap,tabStack,8*sizeof(double));
 183   SequenceAnyPtr tmp(SequenceAny::New(tabStack,8,0));
 184   CPPUNIT_ASSERT_EQUAL(8,(int)tmp->size());
 185   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 186   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 187   AtomAnyPtr tmp2(AtomAny::New(8.9));
 188   tmp->pushBack(tmp2);
 189   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 190   tmp2=AtomAny::New(10.2);
 191   tmp->pushBack(tmp2);
 192   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 193   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 194   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.2,(*tmp)[9]->getDoubleValue(),1e-12);
 195   tmp->popBack();
 196   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 197   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 198   tmp2=AtomAny::New(10.3);
 199   tmp->pushBack(tmp2);
 200   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 201   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 202   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.3,(*tmp)[9]->getDoubleValue(),1e-12);
 203   tmp=SequenceAny::New(tabHeap,8,toto2);
 204   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 205   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 206   tmp2=AtomAny::New(8.5);
 207   tmp->pushBack(tmp2);
 208   tmp2=AtomAny::New(10.27);
 209   tmp->pushBack(tmp2);
 210   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 211   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.27,(*tmp)[9]->getDoubleValue(),1e-12);
 212   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 213   tmp->popBack();
 214   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 215   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 216   tmp2=AtomAny::New(10.445);
 217   tmp->pushBack(tmp2);
 218   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 219   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 220   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.445,(*tmp)[9]->getDoubleValue(),1e-12);
 221   // Idem but for int
 222   int tabStackI[8]={1, 3, 5, 7, 9, 2, 4, 6};
 223   int *tabHeapI=new int[8];
 224   memcpy(tabHeapI,tabStackI,8*sizeof(int));
 225   tmp=SequenceAny::New(tabStackI,8,0);
 226   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 227   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 228   tmp2=AtomAny::New(8);
 229   tmp->pushBack(tmp2);
 230   tmp2=AtomAny::New(25);
 231   tmp->pushBack(tmp2);
 232   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 233   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 234   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 235   CPPUNIT_ASSERT_EQUAL(25,(*tmp)[9]->getIntValue());
 236   //Same with no copy constructor
 237   tmp=SequenceAny::New(tabHeapI,8,toto3);
 238   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 239   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 240   tmp2=AtomAny::New(8);
 241   tmp->pushBack(tmp2);
 242   tmp2=AtomAny::New(27);
 243   tmp->pushBack(tmp2);
 244   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 245   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 246   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 247   CPPUNIT_ASSERT_EQUAL(27,(*tmp)[9]->getIntValue());
 248   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 249   tmp->popBack();
 250   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 251   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 252   tmp2=AtomAny::New(202);
 253   tmp->pushBack(tmp2);
 254   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 255   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 256   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 257   try
 258     {
 259       double d=(*tmp)[2]->getDoubleValue();
 260       CPPUNIT_ASSERT(0);
 261     }
 262   catch(Exception& e)
 263     {
 264       CPPUNIT_ASSERT(std::string(e.what())=="Value is not a double");
 265     }
 266   SequenceAnyPtr tmp3=SequenceAny::New(tmp->getType());
 267   try
 268     {
 269       tmp3->pushBack(tmp2);
 270       CPPUNIT_ASSERT(0);
 271     }
 272   catch(Exception& e)
 273     {
 274       CPPUNIT_ASSERT(std::string(e.what())=="Invalid runtime of YACS::Any struct : having int and you want Sequence");
 275     }
 276   CPPUNIT_ASSERT_EQUAL(0,(int)tmp3->size());
 277   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 278   tmp3->pushBack(tmp);
 279   CPPUNIT_ASSERT_EQUAL(1,(int)tmp3->size());
 280   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 281   tmp=SequenceAny::New(tabStackI,8,0);
 282   tmp3->pushBack(tmp);
 283   CPPUNIT_ASSERT_EQUAL(2,(int)tmp3->size());
 284   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 285   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 286   tmp3->pushBack(tmp);
 287   tmp3->pushBack(tmp);
 288   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 289   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 290   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 291   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[3][3]->getIntValue());
 292   tmp2=AtomAny::New(89);
 293   tmp->pushBack(tmp2);
 294   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 295   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 296   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 297   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 298   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 299   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[3][8]->getIntValue());
 300   tmp3->popBack();
 301   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 302   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 303   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 304   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 305   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 306   SequenceAnyPtr tmp4=(SequenceAny *)tmp3->clone();
 307   CPPUNIT_ASSERT_EQUAL(3,(int)tmp4->size());
 308   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 309   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 310   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[2][8]->getIntValue());
 311   tmp4->popBack();
 312   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 313   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 314   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 315   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 316   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 317   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 318   tmp->popBack();
 319   tmp2=AtomAny::New(107);
 320   tmp->pushBack(tmp2);
 321   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 322   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 323   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 324   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 325   CPPUNIT_ASSERT_EQUAL(107,(*tmp3)[1][8]->getIntValue());//These 2 lines to show that deepCpy has been done
 326   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 327 }
 328
 329 void EngineTest::checkAny3()
 330 {
 331   vector<string> vec;
 332   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 333   SequenceAnyPtr tmp(SequenceAny::New(vec));
 334   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 335   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 336   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 337   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 338   tmp->pushBack(AtomAnyPtr(AtomAny::New("abcdefgh")));
 339   CPPUNIT_ASSERT_EQUAL(4,(int)tmp->size());
 340   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 341   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 342   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 343   CPPUNIT_ASSERT((*tmp)[3]->getStringValue()=="abcdefgh");
 344   tmp->popBack();
 345   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 346   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 347   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 348   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 349   tmp->popBack();
 350   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 351   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 352   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 353   tmp->popBack();
 354   CPPUNIT_ASSERT_EQUAL(1,(int)tmp->size());
 355   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 356   tmp->popBack();
 357   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 358   //
 359   vector<bool> vec2;
 360   tmp=SequenceAny::New(vec2);
 361   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 362   vec2.push_back(true); vec2.push_back(false); vec2.push_back(true); vec2.push_back(true); vec2.push_back(true);
 363   tmp=SequenceAny::New(vec2);
 364   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 365   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 366   //in perspective of SequenceAny of bool were optimized as std::vector<bool> does.
 367   tmp->pushBack(AtomAnyPtr(AtomAny::New(false))); tmp->pushBack(AtomAnyPtr(AtomAny::New(true))); tmp->pushBack(AtomAnyPtr(AtomAny::New(false)));
 368   tmp->pushBack(AtomAnyPtr(AtomAny::New(true)));
 369   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 370   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 371   CPPUNIT_ASSERT(!(*tmp)[5]->getBoolValue() && (*tmp)[6]->getBoolValue() && !(*tmp)[7]->getBoolValue() && (*tmp)[8]->getBoolValue());
 372   //
 373   vector<int> vec3;
 374   vec3.push_back(2); vec3.push_back(5); vec3.push_back(7); vec3.push_back(1); vec3.push_back(66); vec3.push_back(26);
 375   tmp=SequenceAny::New(vec3);
 376   CPPUNIT_ASSERT_EQUAL(6,(int)tmp->size());
 377   CPPUNIT_ASSERT_EQUAL(26,(*tmp)[5]->getIntValue());
 378   tmp->popBack();
 379   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 380   //
 381   vector<double> vec4;
 382   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 383   tmp=SequenceAny::New(vec4);
 384   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 385   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.07,(*tmp)[2]->getDoubleValue(),1e-12);
 386   tmp->popBack();
 387   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 388   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1]->getDoubleValue(),1e-12);
 389 }
 390
 391 void EngineTest::checkAny4()
 392 {
 393   SequenceAnyPtr tmp(SequenceAny::New(Runtime::_tc_int,8));
 394   tmp=SequenceAny::New(Runtime::_tc_int,4);
 395   tmp=SequenceAny::New(Runtime::_tc_int);
 396   tmp=SequenceAny::New(Runtime::_tc_int,7);
 397   AnyPtr tmp2=AtomAny::New(107);
 398   tmp->setEltAtRank(3,tmp2);
 399   CPPUNIT_ASSERT_EQUAL(107,(*tmp)[3]->getIntValue());
 400   tmp=SequenceAny::New(Runtime::_tc_string,2);
 401   const char tmpSt[]="titi";
 402   tmp2=AtomAny::New((char*)tmpSt,0);
 403   tmp->setEltAtRank(1,tmp2);
 404   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="titi");
 405   vector<double> vec4;
 406   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 407   tmp2=SequenceAny::New(vec4);
 408   tmp=SequenceAny::New(tmp2->getType(),3);
 409   tmp->setEltAtRank(0,tmp2);
 410   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[0][1]->getDoubleValue(),1e-12);
 411   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 412   tmp->clear();
 413   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 414   tmp->pushBack(tmp2);
 415   tmp->pushBack(tmp2);
 416   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 417   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1][1]->getDoubleValue(),1e-12);
 418 }
 419
 420 /*!
 421  * Testing Any::operator ==
 422  */
 423 void EngineTest::checkAny5()
 424 {
 425   //AtomAny
 426   AnyPtr tmp1=AtomAny::New(107);
 427   AnyPtr tmp2=AtomAny::New(107);
 428   CPPUNIT_ASSERT( *tmp1==*tmp2 );
 429   tmp1=AtomAny::New(106);
 430   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 431   CPPUNIT_ASSERT( ! (*tmp2==*tmp1) );
 432   tmp1=AtomAny::New("toto");
 433   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 434   tmp2=AtomAny::New("tot");
 435   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 436   tmp2=AtomAny::New("toto");
 437   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 438   tmp1=AtomAny::New("mmmmmlll");
 439   tmp2=tmp1->clone();
 440   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 441   //SequenceAny
 442   vector<string> vec;
 443   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 444   SequenceAnyPtr tmp3=(SequenceAny::New(vec));
 445   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 446   CPPUNIT_ASSERT((*tmp3)[0]->getStringValue()=="tata00000");
 447   CPPUNIT_ASSERT((*tmp3)[1]->getStringValue()=="toto");
 448   CPPUNIT_ASSERT((*tmp3)[2]->getStringValue()=="tutu");
 449   AnyPtr tmp4=tmp3->clone();
 450   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 451   CPPUNIT_ASSERT( (*tmp3==*tmp3) );
 452   tmp3->popBack();
 453   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 454   tmp1=AtomAny::New("tutu");
 455   tmp3->pushBack(tmp1);
 456   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 457    tmp3->pushBack(tmp1);
 458   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 459   tmp3->popBack();
 460   CPPUNIT_ASSERT( *tmp3==*tmp4 );
 461   tmp3->popBack();
 462   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 463   tmp1=AtomAny::New("tutug");
 464   tmp3->pushBack(tmp1);
 465   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 466 }
 467
 468 /*!
 469  * Test of ArrayAny. Only one level.
 470  */
 471 void EngineTest::checkAny6()
 472 {
 473   const int lgth=8;
 474   const int tab[lgth]={0,1,1,9,2,7,2,3};
 475   const int tab2[lgth]={13,1,1,9,2,7,2,3};
 476   ArrayAnyPtr tmp1(ArrayAny::New(tab,lgth));
 477   ArrayAnyPtr tmp2(ArrayAny::New(tab,lgth));
 478   CPPUNIT_ASSERT((*tmp1)[3]->getIntValue()==9);
 479   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 480   CPPUNIT_ASSERT( (*tmp1==*tmp1) );
 481   CPPUNIT_ASSERT( 8==tmp1->size() );
 482   CPPUNIT_ASSERT( 8==tmp2->size() );
 483   tmp2=ArrayAny::New(tab,lgth-1);
 484   CPPUNIT_ASSERT( 7==tmp2->size() );
 485   CPPUNIT_ASSERT( !(*tmp1==*tmp2) );
 486   tmp2=ArrayAny::New(tab2,lgth);
 487   CPPUNIT_ASSERT( !(*tmp1==*tmp2) );
 488   tmp2=ArrayAny::New(tab,lgth);
 489   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 490   ArrayAnyPtr tmp3=(ArrayAny *)tmp1->clone();
 491   CPPUNIT_ASSERT( (*tmp1==*tmp3) );
 492   CPPUNIT_ASSERT((*tmp3)[3]->getIntValue()==9); CPPUNIT_ASSERT((*tmp3)[4]->getIntValue()==2);
 493   // Ok let's test with double.
 494   const double tab3[lgth]={0.1,1.1,1.1,9.1,2.1,7.1,2.1,3.1};
 495   const double tab4[lgth]={13.1,1.1,1.1,9.1,2.1,7.1,2.1,3.1};
 496   ArrayAnyPtr tmp4(ArrayAny::New(tab3,lgth));
 497   ArrayAnyPtr tmp5(ArrayAny::New(tab3,lgth));
 498   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp4)[3]->getDoubleValue(),9.1,1e-12);
 499   CPPUNIT_ASSERT( (*tmp4==*tmp5) );
 500   CPPUNIT_ASSERT( (*tmp4==*tmp4) );
 501   CPPUNIT_ASSERT( 8==tmp4->size() );
 502   CPPUNIT_ASSERT( 8==tmp5->size() );
 503   tmp5=ArrayAny::New(tab3,lgth-1);
 504   CPPUNIT_ASSERT( 7==tmp5->size() );
 505   CPPUNIT_ASSERT( !(*tmp4==*tmp5) );
 506   tmp5=ArrayAny::New(tab4,lgth);
 507   CPPUNIT_ASSERT( !(*tmp4==*tmp5) );
 508   tmp5=ArrayAny::New(tab3,lgth);
 509   CPPUNIT_ASSERT( (*tmp4==*tmp5) );
 510   ArrayAnyPtr tmp6=(ArrayAny *)tmp4->clone();
 511   CPPUNIT_ASSERT( (*tmp4==*tmp6) );
 512   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp6)[3]->getDoubleValue(),9.1,1e-12);
 513   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp6)[4]->getDoubleValue(),2.1,1e-12);
 514   //Ok let's test with bool.
 515   const bool tab5[lgth]={false,true,false,true,false,false,false,false};
 516   const bool tab6[lgth]={true ,true,false,true,false,false,false,false};
 517   ArrayAnyPtr tmp7(ArrayAny::New(tab5,lgth));
 518   ArrayAnyPtr tmp8(ArrayAny::New(tab5,lgth));
 519   CPPUNIT_ASSERT((*tmp7)[3]->getBoolValue());
 520   CPPUNIT_ASSERT( (*tmp7==*tmp8) );
 521   CPPUNIT_ASSERT( (*tmp7==*tmp7) );
 522   CPPUNIT_ASSERT( 8==tmp7->size() );
 523   CPPUNIT_ASSERT( 8==tmp8->size() );
 524   tmp8=ArrayAny::New(tab5,lgth-1);
 525   CPPUNIT_ASSERT( 7==tmp8->size() );
 526   CPPUNIT_ASSERT( !(*tmp7==*tmp8) );
 527   tmp8=ArrayAny::New(tab6,lgth);
 528   CPPUNIT_ASSERT( !(*tmp7==*tmp8) );
 529   tmp8=ArrayAny::New(tab5,lgth);
 530   CPPUNIT_ASSERT( (*tmp7==*tmp8) );
 531   ArrayAnyPtr tmp9=(ArrayAny *)tmp7->clone();
 532   CPPUNIT_ASSERT( (*tmp9==*tmp7) );
 533   CPPUNIT_ASSERT((*tmp8)[3]->getBoolValue());
 534   CPPUNIT_ASSERT(!(*tmp8)[4]->getBoolValue());
 535   //Ok let's test with strings.
 536   vector<string> tab7(lgth); tab7[0]="abc"; tab7[1]="def"; tab7[2]="ghi"; tab7[3]="jkl"; tab7[4]="mno"; tab7[5]="pqr"; tab7[6]="stu"; tab7[7]="vwx";
 537   vector<string> tab8(lgth); tab8[0]="zbc"; tab8[1]="def"; tab8[2]="ghi"; tab8[3]="jkl"; tab8[4]="mno"; tab8[5]="pqr"; tab8[6]="stu"; tab8[7]="vwx";
 538   ArrayAnyPtr tmp10(ArrayAny::New(tab7));
 539   ArrayAnyPtr tmp11(ArrayAny::New(tab7));
 540   CPPUNIT_ASSERT((*tmp10)[3]->getStringValue()=="jkl");
 541   CPPUNIT_ASSERT( (*tmp10==*tmp11) );
 542   CPPUNIT_ASSERT( (*tmp10==*tmp10) );
 543   CPPUNIT_ASSERT( 8==tmp10->size() );
 544   CPPUNIT_ASSERT( 8==tmp11->size() );
 545   vector<string> tab9(tab7); tab9.pop_back();
 546   tmp11=ArrayAny::New(tab9);
 547   CPPUNIT_ASSERT( 7==tmp11->size() );
 548   CPPUNIT_ASSERT( !(*tmp10==*tmp11) );
 549   tmp11=ArrayAny::New(tab8);
 550   CPPUNIT_ASSERT( !(*tmp10==*tmp11) );
 551   tmp11=ArrayAny::New(tab7);
 552   CPPUNIT_ASSERT( (*tmp10==*tmp11) );
 553   ArrayAnyPtr tmp12=(ArrayAny *)tmp10->clone();
 554   CPPUNIT_ASSERT( (*tmp12==*tmp10) );
 555   CPPUNIT_ASSERT((*tmp11)[3]->getStringValue()=="jkl");
 556   CPPUNIT_ASSERT((*tmp11)[4]->getStringValue()=="mno");
 557 }
 558
 559 /*!
 560  * Test of ArrayAny on multi-levels. To test recursion.
 561  */
 562 void EngineTest::checkAny7()
 563 {
 564   const int lgth=8;
 565   const int tab1[lgth]={0,1,1,9,2,7,2,3};
 566   const int tab2[lgth]={7,8,8,16,9,14,9,10};
 567   //Testing Arrays of arrays
 568   ArrayAnyPtr tmp11(ArrayAny::New(tab1,lgth));
 569   ArrayAnyPtr tmp12(ArrayAny::New(tab2,lgth));
 570   ArrayAnyPtr tmp12Throw(ArrayAny::New(tab2,lgth+1));
 571   ArrayAnyPtr tmp2(ArrayAny::New(tmp11->getType(),2));
 572   tmp2->setEltAtRank(0,tmp11);
 573   CPPUNIT_ASSERT_THROW(tmp2->setEltAtRank(1,tmp12Throw),Exception);
 574   tmp2->setEltAtRank(1,tmp12);
 575   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 576   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 577   //    Show deep copy process of arrays
 578   AnyPtr tmp=AtomAny::New(49);
 579   tmp11->setEltAtRank(0,tmp);
 580   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 581   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 582   ArrayAnyPtr tmp2Cloned=(ArrayAny *)(tmp2->clone());
 583   CPPUNIT_ASSERT_EQUAL(0,(*tmp2Cloned)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2Cloned)[1][0]->getIntValue());
 584   CPPUNIT_ASSERT_EQUAL(9,(*tmp2Cloned)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2Cloned)[1][3]->getIntValue());
 585   CPPUNIT_ASSERT( *tmp2==*tmp2Cloned );
 586   CPPUNIT_ASSERT( *tmp2==*tmp2 );
 587   //Testing Array of Sequences
 588   SequenceAnyPtr tmp13(SequenceAny::New((int *)tab1,lgth,0));
 589   SequenceAnyPtr tmp14(SequenceAny::New((int *)tab2,lgth,0));
 590   tmp2=ArrayAny::New(tmp13->getType(),2);
 591   tmp2->setEltAtRank(0,tmp13);
 592   tmp2->setEltAtRank(1,tmp14);
 593   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 594   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 595   tmp13->setEltAtRank(0,tmp);
 596   //    No deep copy here contrary to 14 lines ahead.
 597   CPPUNIT_ASSERT_EQUAL(49,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 598   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 599   tmp2Cloned=(ArrayAny *)(tmp2->clone());
 600   CPPUNIT_ASSERT_EQUAL(49,(*tmp2Cloned)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2Cloned)[1][0]->getIntValue());
 601   CPPUNIT_ASSERT_EQUAL(9,(*tmp2Cloned)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2Cloned)[1][3]->getIntValue());
 602   CPPUNIT_ASSERT( *tmp2==*tmp2Cloned );
 603   CPPUNIT_ASSERT( *tmp2==*tmp2 );
 604   //Testing Sequence of array
 605   tmp13=SequenceAny::New(tmp11->getType(),2);
 606   tmp13->setEltAtRank(0,tmp11);
 607   tmp13->setEltAtRank(1,tmp12);
 608   CPPUNIT_ASSERT_EQUAL(49,(*tmp13)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp13)[1][0]->getIntValue());
 609   CPPUNIT_ASSERT_EQUAL(9,(*tmp13)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp13)[1][3]->getIntValue());
 610   tmp14=(SequenceAny *)tmp13->clone();
 611   CPPUNIT_ASSERT_EQUAL(49,(*tmp14)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp14)[1][0]->getIntValue());
 612   CPPUNIT_ASSERT_EQUAL(9,(*tmp14)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp14)[1][3]->getIntValue());
 613   CPPUNIT_ASSERT( *tmp13==*tmp14 );
 614   CPPUNIT_ASSERT( *tmp13==*tmp13 );
 615 }
 616
 617 /*!
 618  * First test of structs.
 619  */
 620 void EngineTest::checkAny8()
 621 {
 622   TypeCodeStruct *tc=new TypeCodeStruct("","");
 623   tc->addMember("MyInt",Runtime::_tc_int);
 624   tc->addMember("MyDouble",Runtime::_tc_double);
 625   tc->addMember("MyBool",Runtime::_tc_bool);
 626   tc->addMember("MyStr",Runtime::_tc_string);
 627   StructAnyPtr tmp1=StructAny::New(tc);
 628   tmp1=StructAny::New(tc);
 629   AnyPtr tmpAtom=AtomAny::New(3791);
 630   tmp1->setEltAtRank("MyInt",tmpAtom);
 631   CPPUNIT_ASSERT_THROW(tmp1->setEltAtRank(1,tmpAtom),Exception);
 632   tmpAtom=AtomAny::New(3.14);
 633   CPPUNIT_ASSERT_THROW(tmp1->setEltAtRank("MyDoubl",tmpAtom),Exception);
 634   tmp1->setEltAtRank("MyDouble",tmpAtom);
 635   tmpAtom=AtomAny::New(false);
 636   tmp1->setEltAtRank("MyBool",tmpAtom);
 637   tmpAtom=AtomAny::New("abcdef");
 638   tmp1->setEltAtRank("MyStr",tmpAtom);
 639   CPPUNIT_ASSERT_EQUAL(3791,(*tmp1)["MyInt"]->getIntValue());
 640   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp1)["MyDouble"]->getDoubleValue(),1e-12);
 641   CPPUNIT_ASSERT_THROW((*tmp1)["MyIntT"],Exception);
 642   CPPUNIT_ASSERT(!(*tmp1)["MyBool"]->getBoolValue());
 643   CPPUNIT_ASSERT_THROW((*tmp1)["MyBool"]->getStringValue(),Exception);
 644   CPPUNIT_ASSERT((*tmp1)["MyStr"]->getStringValue()=="abcdef");
 645   tmpAtom=AtomAny::New("ghijklm");
 646   tmp1->setEltAtRank("MyStr",tmpAtom);
 647   CPPUNIT_ASSERT((*tmp1)["MyStr"]->getStringValue()=="ghijklm");
 648   //Introduce some recursive structure.
 649   SequenceAnyPtr tmp2=SequenceAny::New(tc,2);
 650   tmp2->setEltAtRank(0,tmp1);
 651   tmpAtom=AtomAny::New("opqrst");
 652   tmp1->setEltAtRank("MyStr",tmpAtom);
 653   tmp2->setEltAtRank(1,tmp1);
 654   CPPUNIT_ASSERT_EQUAL(3791,(*tmp2)[1]["MyInt"]->getIntValue());
 655   CPPUNIT_ASSERT((*tmp2)[0]["MyStr"]->getStringValue()=="ghijklm");
 656   CPPUNIT_ASSERT((*tmp2)[1]["MyStr"]->getStringValue()=="opqrst");
 657   CPPUNIT_ASSERT(*tmp2==*tmp2);
 658   AnyPtr tmp3=tmp2->clone();
 659   CPPUNIT_ASSERT(*tmp2==*tmp3);
 660   CPPUNIT_ASSERT((*tmp3)[0]["MyStr"]->getStringValue()=="ghijklm");
 661   CPPUNIT_ASSERT((*tmp3)[1]["MyStr"]->getStringValue()=="opqrst");
 662   tc->decrRef();
 663 }
 664
 665 void EngineTest::checkInGateOutGate()
 666 {
 667   string nodeName = "Node1";
 668   ElementaryNode* node1 = new TestElemNode(nodeName);
 669   _nodeMap[nodeName] = node1;
 670
 671   nodeName = "Node2";
 672   ElementaryNode* node2 = new TestElemNode(nodeName);
 673   _nodeMap[nodeName] = node2;
 674
 675   DEBTRACE(" --- check InGate OK after node creation" );
 676   {
 677     InGate *node1Ingate = node1->getInGate();
 678     CPPUNIT_ASSERT(node1Ingate);
 679     string name=node1Ingate->getNameOfTypeOfCurrentInstance();
 680     string expected="InGate";
 681     CPPUNIT_ASSERT_EQUAL(name,expected);
 682   }
 683
 684   DEBTRACE(" --- check OutGate OK after node creation" );
 685   {
 686     OutGate *node1Outgate = node1->getOutGate();
 687     CPPUNIT_ASSERT(node1Outgate);
 688     string name=node1Outgate->getNameOfTypeOfCurrentInstance();
 689     string expected="OutGate";
 690     CPPUNIT_ASSERT_EQUAL(name,expected);
 691   }
 692 }
 693
 694 void EngineTest::checkNodePortNumber()
 695 {
 696   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 697
 698   DEBTRACE(" --- check number of ports = 0 after node creation" );
 699   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 0);
 700   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 0);
 701
 702   InputPort  *in1 = node1->edAddInputPort("ib1",_tc_bool);
 703   InputPort  *in2 = node1->edAddInputPort("ii1",_tc_int);
 704   InputPort  *in3 = node1->edAddInputPort("ii2",_tc_int);
 705   InputPort  *in4 = node1->edAddInputPort("id1",_tc_double);
 706
 707   OutputPort *ou1 = node1->edAddOutputPort("ob1",_tc_bool);
 708   OutputPort *ou2 = node1->edAddOutputPort("oi1",_tc_int);
 709   OutputPort *ou3 = node1->edAddOutputPort("od1",_tc_double);
 710
 711   DEBTRACE(" --- check number of ports after ports creation" );
 712 //   DEBTRACE("     node1->getNumberOfInputPorts(): "
 713 //         << node1->getNumberOfInputPorts());
 714 //   DEBTRACE("     node1->getNumberOfOutputPorts(): "
 715 //         << node1->getNumberOfOutputPorts());
 716   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 4);
 717   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 718 }
 719
 720 void EngineTest::checkPortTypeName()
 721 {
 722   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 723
 724   DEBTRACE(" --- check InputPort name OK" );
 725   {
 726     string name=node1->getInputPort("ib1")->NAME;
 727     string expected="InputPort";
 728     CPPUNIT_ASSERT_EQUAL(name,expected);
 729   }
 730
 731   DEBTRACE(" --- check OutputPort name OK" );
 732   {
 733     string name=node1->getOutputPort("ob1")->NAME;
 734     string expected="OutputPort";
 735     CPPUNIT_ASSERT_EQUAL(name,expected);
 736   }
 737 }
 738
 739 void EngineTest::checkDuplicatePortName()
 740 {
 741   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 742   DEBTRACE(" --- check duplicated name throws exception" );
 743   CPPUNIT_ASSERT_THROW(InputPort *in5=node1->edAddInputPort("ii2",_tc_int),
 744                        YACS::Exception);
 745 }
 746
 747 void EngineTest::checkRemovePort()
 748 {
 749   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 750   ElementaryNode* node2 = (ElementaryNode*) _nodeMap["Node2"];
 751
 752     DEBTRACE(" --- check remove port" );
 753   {
 754     node1->edRemovePort(node1->getInputPort("ib1"));
 755     CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 3);
 756     CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 757   }
 758
 759   DEBTRACE(" --- check remove wrong port throws exception" )
 760   {
 761     CPPUNIT_ASSERT_THROW(node1->edRemovePort(node1->getInputPort("ib1")),
 762                          YACS::Exception);
 763   }
 764 }
 765
 766 void EngineTest::checkAddNodesToBloc()
 767 {
 768   DEBTRACE(" --- delete node; // ====== NOT OK : done by bloc" );
 769
 770   for (int i=0; i<10; i++)
 771     {
 772       ostringstream ss;
 773       ss << "Node_" << i;
 774       string s = ss.str();
 775       ElementaryNode* node = new TestElemNode(s);
 776       _nodeMap[s] = node;
 777       InputPort  *i1 = node->edAddInputPort("ib1",_tc_bool);
 778       InputPort  *i2 = node->edAddInputPort("ii1",_tc_int);
 779       InputPort  *i3 = node->edAddInputPort("ii2",_tc_int);
 780       InputPort  *i4 = node->edAddInputPort("id1",_tc_double);
 781       OutputPort *o1 = node->edAddOutputPort("ob1",_tc_bool);
 782       OutputPort *o2 = node->edAddOutputPort("oi1",_tc_int);
 783       OutputPort *o3 = node->edAddOutputPort("od1",_tc_double);
 784     }
 785
 786   DEBTRACE(" --- create bloc, add two nodes, check constituants" );
 787
 788   Bloc* bloc1 = new Bloc("bloc1");
 789   _nodeMap["bloc1"] = bloc1;
 790   _compoMap["bloc1"] = bloc1;
 791   bloc1->edAddChild(_nodeMap["Node_1"]);
 792   bloc1->edAddChild(_nodeMap["Node_2"]);
 793   {
 794     list<ElementaryNode *> setelem = bloc1->getRecursiveConstituents();
 795     CPPUNIT_ASSERT(setelem.size() == 2);
 796   }
 797 }
 798
 799 void EngineTest::checkAddingTwiceSameNodeInSameBloc()
 800 {
 801   DEBTRACE(" --- add the same node two times does nothing: return false" );
 802
 803   CPPUNIT_ASSERT(! ((Bloc*)_compoMap["bloc1"])->edAddChild(_nodeMap["Node_1"]));
 804 }
 805
 806 void EngineTest::checkAddingTwiceSameNodeInTwoBlocs()
 807 {
 808   DEBTRACE(" --- add a node already used elsewhere raises exception" );
 809
 810   Bloc* bloc2 = new Bloc("bloc2");
 811   _nodeMap["bloc2"] = bloc2;
 812   _compoMap["bloc2"] = bloc2;
 813   bloc2->edAddChild(_nodeMap["Node_3"]);
 814
 815   CPPUNIT_ASSERT_THROW(bloc2->edAddChild(_nodeMap["Node_1"]),
 816                        YACS::Exception);
 817 }
 818
 819
 820 void EngineTest::checkRecursiveBlocs_NumberOfNodes()
 821 {
 822   Bloc *bloc1 = (Bloc*)_compoMap["bloc1"];
 823   Bloc *bloc2 = (Bloc*)_compoMap["bloc2"];
 824
 825   DEBTRACE(" --- recursive blocs, check constituants" );
 826
 827   Bloc* bloc3 = new Bloc("bloc3");
 828   _nodeMap["bloc3"] = bloc3;
 829   _compoMap["bloc3"] = bloc3;
 830   bloc3->edAddChild((bloc1));  // 2 elementary nodes
 831   bloc3->edAddChild((bloc2));  // 1 elementary node
 832   bloc3->edAddChild(_nodeMap["Node_4"]);   // 1 elementary node
 833   {
 834     list<ElementaryNode *> setelem = bloc3->getRecursiveConstituents();
 835     CPPUNIT_ASSERT(setelem.size() == 4);
 836     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 837       {
 838         DEBTRACE("     elem name = " << (*it)->getName());
 839       }
 840   }
 841 }
 842
 843 void EngineTest::checkRecursiveBlocs_NumberOfPorts()
 844 {
 845   Bloc *bloc3 = (Bloc*)_compoMap["bloc3"];
 846
 847   DEBTRACE(" --- recursive blocs, check input & output ports // COMPLETER" );
 848   CPPUNIT_ASSERT(bloc3->getNumberOfInputPorts() == 4*4);
 849   DEBTRACE("     number of input ports: " << bloc3->getNumberOfInputPorts());
 850   DEBTRACE("     number of output ports: " << bloc3->getNumberOfOutputPorts());
 851   {
 852     list<InputPort *> inset = bloc3->getSetOfInputPort();
 853     list<OutputPort *> outset = bloc3->getSetOfOutputPort();
 854     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 855       {
 856         DEBTRACE("     input port name = " << bloc3->getInPortName(*it));
 857       }
 858     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 859       {
 860         DEBTRACE("     output port name = " << bloc3->getOutPortName(*it));
 861       }
 862   }
 863 }
 864
 865 void EngineTest::checkPortNameInBloc()
 866 {
 867
 868   DEBTRACE(" --- recursive blocs, check port names" );
 869
 870   InputPort *inport = _nodeMap["Node_1"]->getInputPort("id1");
 871   CPPUNIT_ASSERT(_nodeMap["bloc3"]->getInPortName(inport) == "bloc1.Node_1.id1");
 872   CPPUNIT_ASSERT(((Bloc*)_nodeMap["bloc3"])->getChildName(_nodeMap["Node_1"]) == "bloc1.Node_1");
 873 }
 874
 875 void EngineTest::checkGetNameOfPortNotInBloc()
 876 {
 877   InputPort *inport = _nodeMap["Node_5"]->getInputPort("id1");
 878   CPPUNIT_ASSERT_THROW(string name = _nodeMap["bloc3"]->getInPortName(inport),
 879                        YACS::Exception);
 880 }
 881
 882 void EngineTest::checkRemoveNode()
 883 {
 884   DEBTRACE(" --- bloc and port inventory must be OK after bloc remove" );
 885
 886   Bloc* bloc = new Bloc("blocR");
 887   _nodeMap["blocR"] = bloc;
 888   _compoMap["blocR"] = bloc;
 889   bloc->edAddChild(_nodeMap["Node_5"]);
 890   bloc->edAddChild(_nodeMap["Node_6"]);
 891   bloc->edAddChild(_nodeMap["Node_7"]);
 892
 893   {
 894     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 895     CPPUNIT_ASSERT(setelem.size() == 3);
 896
 897     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 898       {
 899         DEBTRACE("     elem name = " << (*it)->getName());
 900       }
 901   }
 902
 903   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_6"]);
 904
 905   {
 906     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 907     CPPUNIT_ASSERT(setelem.size() == 2);
 908     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 909       {
 910         DEBTRACE("     elem name         = " << (*it)->getName());
 911         DEBTRACE("     elem name in Bloc = " << ((Bloc *)_nodeMap["blocR"])->getChildName(*it));
 912       }
 913   }
 914
 915   {
 916     list<InputPort *> inset = _nodeMap["blocR"]->getSetOfInputPort();
 917     list<OutputPort *> outset = _nodeMap["blocR"]->getSetOfOutputPort();
 918     CPPUNIT_ASSERT(inset.size() == 8);
 919     CPPUNIT_ASSERT(outset.size() == 6);
 920     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 921       {
 922         DEBTRACE("     input port name for blocR  = " << _nodeMap["blocR"]->getInPortName(*it));
 923       }
 924     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 925       {
 926         DEBTRACE("     output port name for blocR  = " << _nodeMap["blocR"]->getOutPortName(*it));
 927       }
 928   }
 929
 930   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_5"]);
 931   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_7"]);
 932   {
 933     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 934     CPPUNIT_ASSERT(setelem.size() == 0);
 935   }
 936 }
 937
 938 void EngineTest::RecursiveBlocs_multipleRecursion()
 939 {
 940   {
 941     Bloc* bloc = new Bloc("bloc4");
 942     _nodeMap["bloc4"] = bloc;
 943     _compoMap["bloc4"] = bloc;
 944     bloc->edAddChild(_nodeMap["Node_5"]);
 945     bloc->edAddChild(_nodeMap["Node_6"]);
 946   }
 947
 948   {
 949     Bloc* bloc = new Bloc("bloc5");
 950     _nodeMap["bloc5"] = bloc;
 951     _compoMap["bloc5"] = bloc;
 952     bloc->edAddChild(_nodeMap["Node_7"]);
 953     bloc->edAddChild(_nodeMap["Node_8"]);
 954   }
 955
 956   {
 957     Bloc* bloc = new Bloc("bloc6");
 958     _nodeMap["bloc6"] = bloc;
 959     _compoMap["bloc6"] = bloc;
 960     bloc->edAddChild(_nodeMap["bloc4"]);
 961     bloc->edAddChild(_nodeMap["bloc5"]);
 962   }
 963
 964   {
 965     Bloc* bloc = new Bloc("bloc7");
 966     _nodeMap["bloc7"] = bloc;
 967     _compoMap["bloc7"] = bloc;
 968     bloc->edAddChild(_nodeMap["bloc3"]);
 969     bloc->edAddChild(_nodeMap["bloc6"]);
 970   }
 971
 972   {
 973     Bloc* bloc = new Bloc("graphe");
 974     _nodeMap["graphe"] = bloc;
 975     _compoMap["graphe"] = bloc;
 976     bloc->edAddChild(_nodeMap["bloc7"]);
 977     bloc->edAddChild(_nodeMap["Node_9"]);
 978   }
 979
 980   {
 981     list<ElementaryNode *> setelem = _nodeMap["graphe"]->getRecursiveConstituents();
 982     CPPUNIT_ASSERT(setelem.size() == 9);
 983     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 984       {
 985         DEBTRACE("     elem name = " << (*it)->getName());
 986       }
 987   }
 988
 989   {
 990     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
 991     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
 992     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 993       {
 994         DEBTRACE("     input port name for bloc7  = " << _nodeMap["bloc7"]->getInPortName(*it));
 995         DEBTRACE("     input port name for graphe = " << _nodeMap["graphe"]->getInPortName(*it));
 996       }
 997     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 998       {
 999         DEBTRACE("     output port name for bloc7  = " << _nodeMap["bloc7"]->getOutPortName(*it));
1000         DEBTRACE("     output port name for graphe = " << _nodeMap["graphe"]->getOutPortName(*it));
1001       }
1002     YACS::ENGINE::VisitorSaveState vst(_compoMap["graphe"]);
1003     vst.openFileDump("dumpState.xml");
1004     _compoMap["graphe"]->accept(&vst);
1005     vst.closeFileDump();
1006   }
1007 }
1008
1009 void EngineTest::RecursiveBlocs_removeNodes()
1010 {
1011 //   {
1012 //     set<Node *> setNodes = ((Bloc*)_nodeMap["graphe"])->getChildren();
1013 //     for (set<Node*>::iterator it=setNodes.begin(); it!=setNodes.end(); it++)
1014 //       {
1015 //      DEBTRACE("     child name = " << (*it)->getName());
1016 //       }
1017 //   }
1018
1019   {
1020     list<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
1021     CPPUNIT_ASSERT(setNode.size() == 16);
1022     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
1023     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
1024     DEBTRACE("     input port number in graph:  " <<inset.size());
1025     DEBTRACE("     output port number in graph: " <<outset.size());
1026     CPPUNIT_ASSERT(inset.size() == 32);
1027     CPPUNIT_ASSERT(outset.size() == 24);
1028   }
1029
1030   ((Bloc *)_nodeMap["bloc7"])->edRemoveChild(_nodeMap["bloc6"]);
1031
1032   {
1033     list<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
1034     CPPUNIT_ASSERT(setNode.size() == 9);
1035     for (list<Node*>::iterator it=setNode.begin(); it!=setNode.end(); it++)
1036       {
1037         DEBTRACE("     elem name = " << ((Bloc *)_nodeMap["graphe"])->getChildName(*it));
1038       }
1039     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
1040     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
1041     DEBTRACE("     input port number in graph:  " <<inset.size());
1042     DEBTRACE("     output port number in graph: " <<outset.size());
1043     CPPUNIT_ASSERT(inset.size() == 16);
1044     CPPUNIT_ASSERT(outset.size() == 12);
1045   }
1046
1047 }
1048
1049 void EngineTest::checkLogger()
1050 {
1051   Proc* proc=new Proc("proc");
1052   Logger* logger=proc->getLogger("parser");
1053   logger->error("error1","file.cxx",324);
1054   logger->error("error2","file.cxx",852);
1055   CPPUNIT_ASSERT(logger->hasErrors()==true);
1056   CPPUNIT_ASSERT(logger->isEmpty()==false);
1057   const char* expected1="LogRecord: parser:ERROR:error1 (file.cxx:324)\n"
1058                         "LogRecord: parser:ERROR:error2 (file.cxx:852)\n";
1059   CPPUNIT_ASSERT(logger->getStr()==expected1);
1060
1061   logger->reset();
1062   CPPUNIT_ASSERT(logger->hasErrors()==false);
1063   CPPUNIT_ASSERT(logger->isEmpty()==true);
1064
1065   logger->error("error1","file.cxx",324);
1066   logger->error("error2","file.cxx",852);
1067   logger->error("error3","file.cxx",978);
1068   CPPUNIT_ASSERT(logger->hasErrors()==true);
1069   CPPUNIT_ASSERT(logger->isEmpty()==false);
1070   const char* expected2="LogRecord: parser:ERROR:error1 (file.cxx:324)\n"
1071                         "LogRecord: parser:ERROR:error2 (file.cxx:852)\n"
1072                         "LogRecord: parser:ERROR:error3 (file.cxx:978)\n";
1073   CPPUNIT_ASSERT(logger->getStr()==expected2);
1074   delete proc;
1075 }
1076
1077 void EngineTest::checkGraphAnalyser0()
1078 {
1079   {
1080     static const int N=2;
1081     Bloc *t[N];
1082     Bloc proc("proc");
1083     for(int i=0;i<N;i++)
1084       {
1085         std::ostringstream oss; oss << "n" << i+1;
1086         t[i]=new Bloc(oss.str());
1087         proc.edAddChild(t[i]);
1088       }
1089     proc.edAddCFLink(t[0],t[1]);
1090     std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
1091     CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
1092     CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
1093     SetOfPoints sop(r[0]);
1094     sop.simplify();
1095     CPPUNIT_ASSERT(sop.getRepr()=="(n1+n2) - ");
1096   }
1097 }
1098
1099 void EngineTest::checkGraphAnalyser1()
1100 {
1101   {
1102     static const int N=24;
1103     Bloc *t[N];
1104     Bloc proc("proc");
1105     for(int i=0;i<N;i++)
1106       {
1107         std::ostringstream oss; oss << "n" << i+1;
1108         t[i]=new Bloc(oss.str());
1109         proc.edAddChild(t[i]);
1110       }
1111     proc.edAddCFLink(t[20],t[21]); proc.edAddCFLink(t[21],t[15]); proc.edAddCFLink(t[15],t[14]); proc.edAddCFLink(t[14],t[0]); proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[23]); proc.edAddCFLink(t[23],t[5]);
1112     proc.edAddCFLink(t[14],t[13]); proc.edAddCFLink(t[13],t[5]);
1113     proc.edAddCFLink(t[15],t[12]); proc.edAddCFLink(t[12],t[11]); proc.edAddCFLink(t[11],t[9]); proc.edAddCFLink(t[9],t[8]); proc.edAddCFLink(t[8],t[7]); proc.edAddCFLink(t[7],t[6]); proc.edAddCFLink(t[6],t[5]);
1114     proc.edAddCFLink(t[11],t[10]); proc.edAddCFLink(t[10],t[8]);
1115     proc.edAddCFLink(t[15],t[16]); proc.edAddCFLink(t[16],t[17]); proc.edAddCFLink(t[17],t[19]); proc.edAddCFLink(t[19],t[2]); proc.edAddCFLink(t[2],t[4]); proc.edAddCFLink(t[4],t[5]);
1116     proc.edAddCFLink(t[19],t[18]); proc.edAddCFLink(t[18],t[4]);
1117     proc.edAddCFLink(t[19],t[3]); proc.edAddCFLink(t[3],t[4]);
1118     proc.edAddCFLink(t[22],t[21]);
1119     std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
1120     CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
1121     CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
1122     SetOfPoints sop(r[0]);
1123     sop.simplify();
1124     CPPUNIT_ASSERT(sop.getRepr()=="([n21*n23]+(n22+n16+[((n13+n12)+[n10*n11]+(n9+n8+n7))*((n17+n18+n20)+[n19*n3*n4]+n5)*(n15+[(n1+n2+n24)*n14])]+n6)) - ");
1125   }
1126   //
1127   {
1128     static const int N=10;
1129     Bloc *t[N];
1130     Bloc proc("proc");
1131     for(int i=0;i<N;i++)
1132       {
1133         std::ostringstream oss; oss << "n" << i+1;
1134         t[i]=new Bloc(oss.str());
1135         proc.edAddChild(t[i]);
1136       }
1137     proc.edAddCFLink(t[9],t[0]); proc.edAddCFLink(t[0],t[2]); proc.edAddCFLink(t[2],t[4]); proc.edAddCFLink(t[4],t[5]);
1138     proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[6]); proc.edAddCFLink(t[6],t[7]); proc.edAddCFLink(t[7],t[5]);
1139     proc.edAddCFLink(t[0],t[8]); proc.edAddCFLink(t[8],t[3]); proc.edAddCFLink(t[3],t[4]);
1140     std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
1141     CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
1142     CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
1143     SetOfPoints sop(r[0]);
1144     sop.simplify();
1145     CPPUNIT_ASSERT(sop.getRepr()=="((n10+n1)+[([(n9+n4)*n3]+n5)*(n2+n7+n8)]+n6) - ");
1146   }
1147 }
1148
1149 void EngineTest::checkGraphAnalyser2()
1150 {
1151   {
1152     static const int N=8;
1153     Bloc *t[N];
1154     Bloc proc("proc");
1155     for(int i=0;i<N;i++)
1156       {
1157         std::ostringstream oss; oss << "n" << i+1;
1158         t[i]=new Bloc(oss.str());
1159         proc.edAddChild(t[i]);
1160       }
1161     proc.edAddCFLink(t[7],t[4]); proc.edAddCFLink(t[4],t[0]); proc.edAddCFLink(t[0],t[1]); proc.edAddCFLink(t[1],t[5]); proc.edAddCFLink(t[5],t[6]);
1162     proc.edAddCFLink(t[4],t[2]); proc.edAddCFLink(t[2],t[3]); proc.edAddCFLink(t[3],t[5]);
1163     std::vector< std::list<Node *> > r(proc.splitIntoIndependantGraph());
1164     CPPUNIT_ASSERT_EQUAL(1,(int)r.size());
1165     CPPUNIT_ASSERT_EQUAL(N,(int)r[0].size());
1166     SetOfPoints sop(r[0]);
1167     sop.simplify();
1168     CPPUNIT_ASSERT(sop.getRepr()=="((n8+n5)+[(n1+n2)*(n3+n4)]+(n6+n7)) - ");
1169   }
1170   //
1171   {
1172     static const int NN=6;
1173     Bloc *tt[NN];
1174     Bloc proc2("proc2");
1175     tt[0]=new Bloc("n21") ; tt[1]=new Bloc("n22") ; tt[2]=new Bloc("n23") ; tt[3]=new Bloc("n16"); tt[4]=new Bloc("n21@1"); tt[5]=new Bloc("n23@1");
1176     for(int i=0;i<NN;i++)
1177       proc2.edAddChild(tt[i]);
1178     proc2.edAddCFLink(tt[0],tt[4]); proc2.edAddCFLink(tt[4],tt[1]); proc2.edAddCFLink(tt[2],tt[5]); proc2.edAddCFLink(tt[5],tt[1]); proc2.edAddCFLink(tt[1],tt[3]);
1179     std::vector< std::list<Node *> > rr(proc2.splitIntoIndependantGraph());
1180     CPPUNIT_ASSERT_EQUAL(1,(int)rr.size());
1181     CPPUNIT_ASSERT_EQUAL(NN,(int)rr[0].size());
1182     SetOfPoints sop2(rr[0]);
1183     sop2.simplify();
1184     CPPUNIT_ASSERT(sop2.getRepr()=="([(n21+n21@1)*(n23+n23@1)]+(n22+n16)) - ");
1185   }
1186   //
1187   {
1188     static const int NNN=6;
1189     Bloc *ttt[NNN];
1190     Bloc proc3("proc3");
1191     ttt[0]=new Bloc("n21") ; ttt[1]=new Bloc("n22") ; ttt[2]=new Bloc("n23") ; ttt[3]=new Bloc("n16"); ttt[4]=new Bloc("n21@1"); ttt[5]=new Bloc("n23@1");
1192     for(int i=0;i<NNN;i++)
1193       proc3.edAddChild(ttt[i]);
1194     proc3.edAddCFLink(ttt[0],ttt[4]); proc3.edAddCFLink(ttt[3],ttt[0]); proc3.edAddCFLink(ttt[2],ttt[5]); proc3.edAddCFLink(ttt[3],ttt[2]); proc3.edAddCFLink(ttt[1],ttt[3]);
1195     std::vector< std::list<Node *> > rrr(proc3.splitIntoIndependantGraph());
1196     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1197     CPPUNIT_ASSERT_EQUAL(NNN,(int)rrr[0].size());
1198     SetOfPoints sop3(rrr[0]);
1199     sop3.simplify();
1200     CPPUNIT_ASSERT(sop3.getRepr()=="((n22+n16)+[(n21+n21@1)*(n23+n23@1)]) - ");
1201   }
1202 }
1203
1204 void EngineTest::checkGraphAnalyser3()
1205 {
1206   {
1207     static const int NNN=6;
1208     Bloc *ttt[NNN];
1209     Bloc proc3("proc3");
1210     for(int i=0;i<NNN;i++)
1211       {
1212         std::ostringstream oss; oss << "n" << i+1;
1213         ttt[i]=new Bloc(oss.str());
1214         proc3.edAddChild(ttt[i]);
1215       }
1216     proc3.edAddCFLink(ttt[0],ttt[1]); proc3.edAddCFLink(ttt[1],ttt[4]);
1217     proc3.edAddCFLink(ttt[0],ttt[2]); proc3.edAddCFLink(ttt[2],ttt[3]); proc3.edAddCFLink(ttt[3],ttt[4]);
1218     proc3.edAddCFLink(ttt[5],ttt[3]);
1219     std::vector< std::list<Node *> > rrr(proc3.splitIntoIndependantGraph());
1220     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1221     CPPUNIT_ASSERT_EQUAL(NNN,(int)rrr[0].size());
1222     SetOfPoints sop3(rrr[0]);
1223     //sop3.simplify();
1224     //std:cerr  << std::endl << sop3.getRepr() << std::endl;
1225     //CPPUNIT_ASSERT(sop3.getRepr()=="((n22+n16)+[(n21+n21@1)*(n23+n23@1)]) - ");
1226   }
1227 }
1228
1229 void EngineTest::checkGraphAnalyser4()
1230 {
1231   {
1232     static const int NNN=3;
1233     Bloc *ttt[NNN];
1234     Bloc proc3("proc");
1235     for(int i=0;i<NNN;i++)
1236       {
1237         std::ostringstream oss; oss << "n" << i+1;
1238         ttt[i]=new Bloc(oss.str());
1239         proc3.edAddChild(ttt[i]);
1240       }
1241     proc3.edAddCFLink(ttt[2],ttt[1]); proc3.edAddCFLink(ttt[1],ttt[0]);
1242     std::vector< std::list<Node *> > rrr(proc3.splitIntoIndependantGraph());
1243     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1244     CPPUNIT_ASSERT_EQUAL(NNN,(int)rrr[0].size());
1245     SetOfPoints sop(rrr[0]);
1246     sop.simplify();
1247     CPPUNIT_ASSERT(sop.getRepr()=="(n3+n2+n1) - ");
1248   }
1249 }
1250
1251 /*!
1252  * Case revealed by EmC2 on complex managers.
1253  * Here basic combination of Link/Fork is not enough.
1254  */
1255 void EngineTest::checkGraphAnalyser5()
1256 {
1257   {
1258     Bloc proc("TOP");
1259     std::vector<Bloc *> vn;
1260     std::vector<std::string> v{"A","E","C","F","D","G"};
1261     std::size_t i=0;
1262     for(auto it : v)
1263       {
1264         Bloc *pt(new Bloc(v[i++]));
1265         proc.edAddChild(pt);
1266         vn.push_back(pt);
1267       }
1268     //
1269     proc.edAddCFLink(vn[0],vn[1]);//A -> E
1270     proc.edAddCFLink(vn[0],vn[2]);//A -> C
1271     proc.edAddCFLink(vn[2],vn[3]);//C -> F
1272     proc.edAddCFLink(vn[2],vn[4]);//C -> D
1273     proc.edAddCFLink(vn[1],vn[3]);//E -> F
1274     proc.edAddCFLink(vn[3],vn[5]);//F -> G
1275     //
1276     std::vector< std::list<Node *> > rrr(proc.splitIntoIndependantGraph());
1277     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1278     CPPUNIT_ASSERT_EQUAL((int)v.size(),(int)rrr[0].size());
1279     SetOfPoints sop(rrr[0]);
1280     sop.simplify();
1281     CPPUNIT_ASSERT(sop.getRepr()=="((A+[C*E])+[(F+G)*[D*E]]) - ");
1282   }
1283   //
1284   {
1285     Bloc proc("TOP");
1286     std::vector<Bloc *> vn;
1287     std::vector<std::string> v{"A","E","C","B","F","D","G"};
1288     std::size_t i=0;
1289     for(auto it : v)
1290       {
1291         Bloc *pt(new Bloc(v[i++]));
1292         proc.edAddChild(pt);
1293         vn.push_back(pt);
1294       }
1295     //
1296     proc.edAddCFLink(vn[0],vn[1]);//A -> E
1297     proc.edAddCFLink(vn[0],vn[2]);//A -> C
1298     proc.edAddCFLink(vn[0],vn[3]);//A -> B
1299     proc.edAddCFLink(vn[3],vn[4]);//B -> F
1300     proc.edAddCFLink(vn[2],vn[4]);//C -> F
1301     proc.edAddCFLink(vn[2],vn[5]);//C -> D
1302     proc.edAddCFLink(vn[1],vn[4]);//E -> F
1303     proc.edAddCFLink(vn[4],vn[6]);//F -> G
1304     //
1305     std::vector< std::list<Node *> > rrr(proc.splitIntoIndependantGraph());
1306     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1307     CPPUNIT_ASSERT_EQUAL((int)v.size(),(int)rrr[0].size());
1308     SetOfPoints sop(rrr[0]);
1309     sop.simplify();
1310     CPPUNIT_ASSERT(sop.getRepr()=="(A+[C*[[B*D]*[D*E]]]+[(F+G)*D]) - ");
1311   }
1312   //
1313   {
1314     Bloc proc("TOP");
1315     std::vector<Bloc *> vn;
1316     std::vector<std::string> v{"A","E","C","B","F","D","G"};
1317     std::size_t i=0;
1318     for(auto it : v)
1319       {
1320         Bloc *pt(new Bloc(v[i++]));
1321         proc.edAddChild(pt);
1322         vn.push_back(pt);
1323       }
1324     //
1325     proc.edAddCFLink(vn[0],vn[1]);//A -> E
1326     proc.edAddCFLink(vn[0],vn[2]);//A -> C
1327     proc.edAddCFLink(vn[0],vn[3]);//A -> B
1328     proc.edAddCFLink(vn[3],vn[4]);//B -> F
1329     proc.edAddCFLink(vn[2],vn[4]);//C -> F
1330     proc.edAddCFLink(vn[2],vn[5]);//C -> D
1331     proc.edAddCFLink(vn[1],vn[4]);//E -> F
1332     proc.edAddCFLink(vn[4],vn[6]);//F -> G
1333     //
1334     std::vector< std::list<Node *> > rrr(proc.splitIntoIndependantGraph());
1335     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1336     CPPUNIT_ASSERT_EQUAL((int)v.size(),(int)rrr[0].size());
1337     SetOfPoints sop(rrr[0]);
1338     sop.simplify();
1339     CPPUNIT_ASSERT(sop.getRepr()=="(A+[C*[[B*D]*[D*E]]]+[(F+G)*D]) - ");
1340   }
1341   //
1342   {
1343     Bloc proc("TOP");
1344     std::vector<Bloc *> vn;
1345     std::vector<std::string> v{"A","I","E","C","B","J","F","H","D","G"};
1346     std::size_t i=0;
1347     for(auto it : v)
1348       {
1349         Bloc *pt(new Bloc(v[i++]));
1350         proc.edAddChild(pt);
1351         vn.push_back(pt);
1352       }
1353     //
1354     proc.edAddCFLink(vn[0],vn[1]);//A -> I
1355     proc.edAddCFLink(vn[0],vn[2]);//A -> E
1356     proc.edAddCFLink(vn[0],vn[3]);//A -> C
1357     proc.edAddCFLink(vn[0],vn[4]);//A -> B
1358     proc.edAddCFLink(vn[4],vn[6]);//B -> F
1359     proc.edAddCFLink(vn[3],vn[7]);//C -> H
1360     proc.edAddCFLink(vn[3],vn[6]);//C -> F
1361     proc.edAddCFLink(vn[3],vn[8]);//C -> D
1362     proc.edAddCFLink(vn[2],vn[6]);//E -> F
1363     proc.edAddCFLink(vn[6],vn[9]);//F -> G
1364     proc.edAddCFLink(vn[9],vn[5]);//G -> J
1365     proc.edAddCFLink(vn[7],vn[5]);//H -> J
1366     proc.edAddCFLink(vn[1],vn[5]);//I -> J
1367     //
1368     std::vector< std::list<Node *> > rrr(proc.splitIntoIndependantGraph());
1369     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1370     CPPUNIT_ASSERT_EQUAL((int)v.size(),(int)rrr[0].size());
1371     SetOfPoints sop(rrr[0]);
1372     sop.simplify();
1373     CPPUNIT_ASSERT(sop.getRepr()=="(A+[([C*[(F+G)*I]]+[([[(F+G)*H]*[(F+G)*I]]+J)*[[(F+G)*D]*[(F+G)*I]]])*[[B*[(F+G)*I]]*[E*[(F+G)*I]]]]) - ");
1374   }
1375   //
1376   {
1377     Bloc proc("TOP");
1378     std::vector<Bloc *> vn;
1379     std::vector<std::string> v{"A","I","E","C","B","J","F","H","D","K","G","L"};
1380     std::size_t i=0;
1381     for(auto it : v)
1382       {
1383         Bloc *pt(new Bloc(v[i++]));
1384         proc.edAddChild(pt);
1385         vn.push_back(pt);
1386       }
1387     //
1388     proc.edAddCFLink(vn[0],vn[1]);//A -> I
1389     proc.edAddCFLink(vn[0],vn[2]);//A -> E
1390     proc.edAddCFLink(vn[0],vn[3]);//A -> C
1391     proc.edAddCFLink(vn[0],vn[4]);//A -> B
1392     proc.edAddCFLink(vn[4],vn[6]);//B -> F
1393     proc.edAddCFLink(vn[3],vn[7]);//C -> H
1394     proc.edAddCFLink(vn[3],vn[6]);//C -> F
1395     proc.edAddCFLink(vn[3],vn[8]);//C -> D
1396     proc.edAddCFLink(vn[2],vn[6]);//E -> F
1397     proc.edAddCFLink(vn[6],vn[10]);//F -> G
1398     proc.edAddCFLink(vn[10],vn[5]);//G -> J
1399     proc.edAddCFLink(vn[7],vn[5]);//H -> J
1400     proc.edAddCFLink(vn[1],vn[5]);//I -> J
1401     proc.edAddCFLink(vn[5],vn[9]);//J -> K
1402     proc.edAddCFLink(vn[9],vn[11]);//K -> L
1403     //
1404     std::vector< std::list<Node *> > rrr(proc.splitIntoIndependantGraph());
1405     CPPUNIT_ASSERT_EQUAL(1,(int)rrr.size());
1406     CPPUNIT_ASSERT_EQUAL((int)v.size(),(int)rrr[0].size());
1407     SetOfPoints sop(rrr[0]);
1408     sop.simplify();
1409     CPPUNIT_ASSERT(sop.getRepr()=="(A+[([C*[(F+G)*I]]+[([[(F+G)*H]*[(F+G)*I]]+(J+K+L))*[[(F+G)*D]*[(F+G)*I]]])*[[B*[(F+G)*I]]*[E*[(F+G)*I]]]]) - ");
1410   }
1411 }