src/engine/Test/engineTest.cxx

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