src/engine/Test/engineTest.cxx

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