src/engine/Test/engineTest.cxx

   1
   2 // --- include from engine first, to avoid redifinition warning _POSIX_C_SOURCE
   3
   4 #include "Bloc.hxx"
   5 #include "Proc.hxx"
   6 #include "Logger.hxx"
   7 #include "ElementaryNode.hxx"
   8 #include "Loop.hxx"
   9 #include "Switch.hxx"
  10 #include "VisitorSaveState.hxx"
  11
  12 #include "SharedPtr.hxx"
  13 #include "RuntimeForEngineTest.hxx"
  14
  15 #include "engineTest.hxx"
  16
  17 #include <iostream>
  18 #include <sstream>
  19 #include <string>
  20 #include <list>
  21 #include <vector>
  22
  23 //#define _DEVDEBUG_
  24 #include "YacsTrace.hxx"
  25
  26 using namespace YACS::ENGINE;
  27 using namespace YACS;
  28 using namespace std;
  29
  30 map<string, Node*> EngineTest::_nodeMap;
  31 map<string, ComposedNode*> EngineTest::_compoMap;
  32
  33 // --- init typecodes
  34
  35 TypeCode *EngineTest::_tc_bool   = new TypeCode(Bool);
  36 TypeCode *EngineTest::_tc_int    = new TypeCode(Int);
  37 TypeCode *EngineTest::_tc_double = new TypeCode(Double);
  38
  39
  40 void EngineTest::setUp()
  41 {
  42 }
  43
  44 void EngineTest::tearDown()
  45 {
  46 }
  47
  48 void EngineTest::cleanUp()
  49 {
  50   map<string, ComposedNode*>::iterator iter2,iter3;
  51   for(map<string, Node*>::iterator iter=_nodeMap.begin();iter!=_nodeMap.end();iter++)
  52     if((*iter).second->getFather()==0)
  53       delete (*iter).second;
  54 }
  55
  56 void EngineTest::checkGetRuntime()
  57 {
  58   CPPUNIT_ASSERT_THROW(Runtime *myrun = getRuntime(), YACS::Exception);
  59   RuntimeForEngineTest::setRuntime();
  60   Runtime *myrun1 = getRuntime();
  61   CPPUNIT_ASSERT(myrun1);
  62   Runtime *myrun2 = getRuntime();
  63   CPPUNIT_ASSERT_EQUAL(myrun1, myrun2);
  64   }
  65
  66 void toto2(void *t)
  67 {
  68   delete [] (char *)t;
  69 }
  70
  71 void toto3(void *t)
  72 {
  73   delete [] (int *)t;
  74 }
  75
  76 void EngineTest::checkAny1()
  77 {
  78   char *toto=new char[10];
  79   strcpy(toto,"lkjlkj");
  80   Any *tmp=AtomAny::New(toto,toto2);//no copy here
  81   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  82   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  83   tmp->incrRef();
  84   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  85   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  86   tmp->decrRef();
  87   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  88   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  89   tmp->decrRef();
  90   const char tmp2[]="coucou";
  91   tmp=AtomAny::New((char *)tmp2,0);
  92   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
  93   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
  94   tmp->decrRef();
  95   tmp=AtomAny::New(string("abcdef"));
  96   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
  97   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
  98   tmp->decrRef();
  99   tmp=AtomAny::New("ghijk");
 100   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 101   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 102   tmp->decrRef();
 103   tmp=AtomAny::New((char *)"ghijk");
 104   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 105   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 106   tmp->decrRef();
 107 }
 108
 109 class A7
 110 {
 111 private:
 112   double _d;
 113   int _cnt;
 114 public:
 115   A7(double toto):_d(toto),_cnt(1) { }
 116   static A7 *New(double toto) { return new A7(toto); }
 117   double getToto() const { return _d; }
 118   void setToto(double val) { _d=val; }
 119   void incrRef() { _cnt++; }
 120   void decrRef();
 121 private:
 122   ~A7() { }
 123 };
 124
 125 void A7::decrRef()
 126 {
 127   if(--_cnt==0)
 128     delete this;
 129 }
 130
 131
 132 void checkSharedPtrFct2(const A7& a)
 133 {
 134   a.getToto();
 135 }
 136
 137 void checkSharedPtrFct1(const SharedPtr<A7>& a)
 138 {
 139   checkSharedPtrFct2(a);
 140 }
 141
 142
 143 void EngineTest::checkSharedPtr()
 144 {
 145   SharedPtr<A7> titi=A7::New(5.);
 146   SharedPtr<A7> toto=A7::New(5.1);
 147   SharedPtr<A7> tutu(toto);
 148   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.,titi->getToto(),1e-12);
 149   titi->setToto(7.1);
 150   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.1,titi->getToto(),1e-12);
 151   checkSharedPtrFct2(titi);
 152   checkSharedPtrFct2(toto);
 153   titi=toto;
 154   checkSharedPtrFct2(titi);
 155   checkSharedPtrFct2(tutu);
 156 }
 157
 158 void EngineTest::checkAny2()
 159 {
 160   double tabStack[8]={1.2, 3.4, 5.6, 7.8, 9.0, 2.3, 4.5, 6.7};
 161   double *tabHeap=new double[8];
 162   memcpy(tabHeap,tabStack,8*sizeof(double));
 163   SequenceAnyPtr tmp(SequenceAny::New(tabStack,8,0));
 164   CPPUNIT_ASSERT_EQUAL(8,(int)tmp->size());
 165   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 166   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 167   AtomAnyPtr tmp2(AtomAny::New(8.9));
 168   tmp->pushBack(tmp2);
 169   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 170   tmp2=AtomAny::New(10.2);
 171   tmp->pushBack(tmp2);
 172   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 173   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 174   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.2,(*tmp)[9]->getDoubleValue(),1e-12);
 175   tmp->popBack();
 176   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 177   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 178   tmp2=AtomAny::New(10.3);
 179   tmp->pushBack(tmp2);
 180   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 181   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 182   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.3,(*tmp)[9]->getDoubleValue(),1e-12);
 183   tmp=SequenceAny::New(tabHeap,8,toto2);
 184   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 185   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 186   tmp2=AtomAny::New(8.5);
 187   tmp->pushBack(tmp2);
 188   tmp2=AtomAny::New(10.27);
 189   tmp->pushBack(tmp2);
 190   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 191   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.27,(*tmp)[9]->getDoubleValue(),1e-12);
 192   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 193   tmp->popBack();
 194   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 195   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 196   tmp2=AtomAny::New(10.445);
 197   tmp->pushBack(tmp2);
 198   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 199   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 200   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.445,(*tmp)[9]->getDoubleValue(),1e-12);
 201   // Idem but for int
 202   int tabStackI[8]={1, 3, 5, 7, 9, 2, 4, 6};
 203   int *tabHeapI=new int[8];
 204   memcpy(tabHeapI,tabStackI,8*sizeof(int));
 205   tmp=SequenceAny::New(tabStackI,8,0);
 206   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 207   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 208   tmp2=AtomAny::New(8);
 209   tmp->pushBack(tmp2);
 210   tmp2=AtomAny::New(25);
 211   tmp->pushBack(tmp2);
 212   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 213   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 214   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 215   CPPUNIT_ASSERT_EQUAL(25,(*tmp)[9]->getIntValue());
 216   //Same with no copy constructor
 217   tmp=SequenceAny::New(tabHeapI,8,toto3);
 218   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 219   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 220   tmp2=AtomAny::New(8);
 221   tmp->pushBack(tmp2);
 222   tmp2=AtomAny::New(27);
 223   tmp->pushBack(tmp2);
 224   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 225   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 226   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 227   CPPUNIT_ASSERT_EQUAL(27,(*tmp)[9]->getIntValue());
 228   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 229   tmp->popBack();
 230   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 231   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 232   tmp2=AtomAny::New(202);
 233   tmp->pushBack(tmp2);
 234   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 235   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 236   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 237   try
 238     {
 239       double d=(*tmp)[2]->getDoubleValue();
 240       CPPUNIT_ASSERT(0);
 241     }
 242   catch(Exception& e)
 243     {
 244       CPPUNIT_ASSERT(std::string(e.what())=="Value is not a Double");
 245     }
 246   SequenceAnyPtr tmp3=SequenceAny::New(tmp->getType());
 247   try
 248     {
 249       tmp3->pushBack(tmp2);
 250       CPPUNIT_ASSERT(0);
 251     }
 252   catch(Exception& e)
 253     {
 254       CPPUNIT_ASSERT(std::string(e.what())=="Invalid runtime of YACS::Any struct : having Int and you want Sequence");
 255     }
 256   CPPUNIT_ASSERT_EQUAL(0,(int)tmp3->size());
 257   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 258   tmp3->pushBack(tmp);
 259   CPPUNIT_ASSERT_EQUAL(1,(int)tmp3->size());
 260   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 261   tmp=SequenceAny::New(tabStackI,8,0);
 262   tmp3->pushBack(tmp);
 263   CPPUNIT_ASSERT_EQUAL(2,(int)tmp3->size());
 264   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 265   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 266   tmp3->pushBack(tmp);
 267   tmp3->pushBack(tmp);
 268   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 269   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 270   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 271   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[3][3]->getIntValue());
 272   tmp2=AtomAny::New(89);
 273   tmp->pushBack(tmp2);
 274   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 275   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 276   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 277   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 278   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 279   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[3][8]->getIntValue());
 280   tmp3->popBack();
 281   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 282   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 283   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 284   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 285   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 286   SequenceAnyPtr tmp4=(SequenceAny *)tmp3->clone();
 287   CPPUNIT_ASSERT_EQUAL(3,(int)tmp4->size());
 288   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 289   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 290   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[2][8]->getIntValue());
 291   tmp4->popBack();
 292   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 293   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 294   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 295   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 296   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 297   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 298   tmp->popBack();
 299   tmp2=AtomAny::New(107);
 300   tmp->pushBack(tmp2);
 301   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 302   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 303   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 304   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 305   CPPUNIT_ASSERT_EQUAL(107,(*tmp3)[1][8]->getIntValue());//These 2 lines to show that deepCpy has been done
 306   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 307 }
 308
 309 void EngineTest::checkAny3()
 310 {
 311   vector<string> vec;
 312   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 313   SequenceAnyPtr tmp(SequenceAny::New(vec));
 314   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 315   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 316   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 317   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 318   tmp->pushBack(AtomAnyPtr(AtomAny::New("abcdefgh")));
 319   CPPUNIT_ASSERT_EQUAL(4,(int)tmp->size());
 320   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 321   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 322   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 323   CPPUNIT_ASSERT((*tmp)[3]->getStringValue()=="abcdefgh");
 324   tmp->popBack();
 325   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 326   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 327   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 328   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 329   tmp->popBack();
 330   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 331   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 332   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 333   tmp->popBack();
 334   CPPUNIT_ASSERT_EQUAL(1,(int)tmp->size());
 335   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 336   tmp->popBack();
 337   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 338   //
 339   vector<bool> vec2;
 340   tmp=SequenceAny::New(vec2);
 341   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 342   vec2.push_back(true); vec2.push_back(false); vec2.push_back(true); vec2.push_back(true); vec2.push_back(true);
 343   tmp=SequenceAny::New(vec2);
 344   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 345   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 346   //in perspective of SequenceAny of bool were optimized as std::vector<bool> does.
 347   tmp->pushBack(AtomAnyPtr(AtomAny::New(false))); tmp->pushBack(AtomAnyPtr(AtomAny::New(true))); tmp->pushBack(AtomAnyPtr(AtomAny::New(false)));
 348   tmp->pushBack(AtomAnyPtr(AtomAny::New(true)));
 349   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 350   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 351   CPPUNIT_ASSERT(!(*tmp)[5]->getBoolValue() && (*tmp)[6]->getBoolValue() && !(*tmp)[7]->getBoolValue() && (*tmp)[8]->getBoolValue());
 352   //
 353   vector<int> vec3;
 354   vec3.push_back(2); vec3.push_back(5); vec3.push_back(7); vec3.push_back(1); vec3.push_back(66); vec3.push_back(26);
 355   tmp=SequenceAny::New(vec3);
 356   CPPUNIT_ASSERT_EQUAL(6,(int)tmp->size());
 357   CPPUNIT_ASSERT_EQUAL(26,(*tmp)[5]->getIntValue());
 358   tmp->popBack();
 359   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 360   //
 361   vector<double> vec4;
 362   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 363   tmp=SequenceAny::New(vec4);
 364   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 365   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.07,(*tmp)[2]->getDoubleValue(),1e-12);
 366   tmp->popBack();
 367   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 368   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1]->getDoubleValue(),1e-12);
 369 }
 370
 371 void EngineTest::checkAny4()
 372 {
 373   SequenceAnyPtr tmp(SequenceAny::New(Runtime::_tc_int,8));
 374   tmp=SequenceAny::New(Runtime::_tc_int,4);
 375   tmp=SequenceAny::New(Runtime::_tc_int);
 376   tmp=SequenceAny::New(Runtime::_tc_int,7);
 377   AnyPtr tmp2=AtomAny::New(107);
 378   tmp->setEltAtRank(3,tmp2);
 379   CPPUNIT_ASSERT_EQUAL(107,(*tmp)[3]->getIntValue());
 380   tmp=SequenceAny::New(Runtime::_tc_string,2);
 381   const char tmpSt[]="titi";
 382   tmp2=AtomAny::New((char*)tmpSt,0);
 383   tmp->setEltAtRank(1,tmp2);
 384   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="titi");
 385   vector<double> vec4;
 386   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 387   tmp2=SequenceAny::New(vec4);
 388   tmp=SequenceAny::New(tmp2->getType(),3);
 389   tmp->setEltAtRank(0,tmp2);
 390   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[0][1]->getDoubleValue(),1e-12);
 391   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 392   tmp->clear();
 393   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 394   tmp->pushBack(tmp2);
 395   tmp->pushBack(tmp2);
 396   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 397   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1][1]->getDoubleValue(),1e-12);
 398 }
 399
 400 /*!
 401  * Testing Any::operator ==
 402  */
 403 void EngineTest::checkAny5()
 404 {
 405   //AtomAny
 406   AnyPtr tmp1=AtomAny::New(107);
 407   AnyPtr tmp2=AtomAny::New(107);
 408   CPPUNIT_ASSERT( *tmp1==*tmp2 );
 409   tmp1=AtomAny::New(106);
 410   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 411   CPPUNIT_ASSERT( ! (*tmp2==*tmp1) );
 412   tmp1=AtomAny::New("toto");
 413   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 414   tmp2=AtomAny::New("tot");
 415   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 416   tmp2=AtomAny::New("toto");
 417   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 418   tmp1=AtomAny::New("mmmmmlll");
 419   tmp2=tmp1->clone();
 420   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 421   //SequenceAny
 422   vector<string> vec;
 423   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 424   SequenceAnyPtr tmp3=(SequenceAny::New(vec));
 425   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 426   CPPUNIT_ASSERT((*tmp3)[0]->getStringValue()=="tata00000");
 427   CPPUNIT_ASSERT((*tmp3)[1]->getStringValue()=="toto");
 428   CPPUNIT_ASSERT((*tmp3)[2]->getStringValue()=="tutu");
 429   AnyPtr tmp4=tmp3->clone();
 430   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 431   CPPUNIT_ASSERT( (*tmp3==*tmp3) );
 432   tmp3->popBack();
 433   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 434   tmp1=AtomAny::New("tutu");
 435   tmp3->pushBack(tmp1);
 436   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 437    tmp3->pushBack(tmp1);
 438   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 439   tmp3->popBack();
 440   CPPUNIT_ASSERT( *tmp3==*tmp4 );
 441   tmp3->popBack();
 442   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 443   tmp1=AtomAny::New("tutug");
 444   tmp3->pushBack(tmp1);
 445   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 446 }
 447
 448 /*!
 449  * Test of ArrayAny. Only one level.
 450  */
 451 void EngineTest::checkAny6()
 452 {
 453   const int lgth=8;
 454   const int tab[lgth]={0,1,1,9,2,7,2,3};
 455   const int tab2[lgth]={13,1,1,9,2,7,2,3};
 456   ArrayAnyPtr tmp1(ArrayAny::New(tab,lgth));
 457   ArrayAnyPtr tmp2(ArrayAny::New(tab,lgth));
 458   CPPUNIT_ASSERT((*tmp1)[3]->getIntValue()==9);
 459   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 460   CPPUNIT_ASSERT( (*tmp1==*tmp1) );
 461   CPPUNIT_ASSERT( 8==tmp1->size() );
 462   CPPUNIT_ASSERT( 8==tmp2->size() );
 463   tmp2=ArrayAny::New(tab,lgth-1);
 464   CPPUNIT_ASSERT( 7==tmp2->size() );
 465   CPPUNIT_ASSERT( !(*tmp1==*tmp2) );
 466   tmp2=ArrayAny::New(tab2,lgth);
 467   CPPUNIT_ASSERT( !(*tmp1==*tmp2) );
 468   tmp2=ArrayAny::New(tab,lgth);
 469   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 470   ArrayAnyPtr tmp3=(ArrayAny *)tmp1->clone();
 471   CPPUNIT_ASSERT( (*tmp1==*tmp3) );
 472   CPPUNIT_ASSERT((*tmp3)[3]->getIntValue()==9); CPPUNIT_ASSERT((*tmp3)[4]->getIntValue()==2);
 473   // Ok let's test with double.
 474   const double tab3[lgth]={0.1,1.1,1.1,9.1,2.1,7.1,2.1,3.1};
 475   const double tab4[lgth]={13.1,1.1,1.1,9.1,2.1,7.1,2.1,3.1};
 476   ArrayAnyPtr tmp4(ArrayAny::New(tab3,lgth));
 477   ArrayAnyPtr tmp5(ArrayAny::New(tab3,lgth));
 478   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp4)[3]->getDoubleValue(),9.1,1e-12);
 479   CPPUNIT_ASSERT( (*tmp4==*tmp5) );
 480   CPPUNIT_ASSERT( (*tmp4==*tmp4) );
 481   CPPUNIT_ASSERT( 8==tmp4->size() );
 482   CPPUNIT_ASSERT( 8==tmp5->size() );
 483   tmp5=ArrayAny::New(tab3,lgth-1);
 484   CPPUNIT_ASSERT( 7==tmp5->size() );
 485   CPPUNIT_ASSERT( !(*tmp4==*tmp5) );
 486   tmp5=ArrayAny::New(tab4,lgth);
 487   CPPUNIT_ASSERT( !(*tmp4==*tmp5) );
 488   tmp5=ArrayAny::New(tab3,lgth);
 489   CPPUNIT_ASSERT( (*tmp4==*tmp5) );
 490   ArrayAnyPtr tmp6=(ArrayAny *)tmp4->clone();
 491   CPPUNIT_ASSERT( (*tmp4==*tmp6) );
 492   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp6)[3]->getDoubleValue(),9.1,1e-12);
 493   CPPUNIT_ASSERT_DOUBLES_EQUAL((*tmp6)[4]->getDoubleValue(),2.1,1e-12);
 494   //Ok let's test with bool.
 495   const bool tab5[lgth]={false,true,false,true,false,false,false,false};
 496   const bool tab6[lgth]={true ,true,false,true,false,false,false,false};
 497   ArrayAnyPtr tmp7(ArrayAny::New(tab5,lgth));
 498   ArrayAnyPtr tmp8(ArrayAny::New(tab5,lgth));
 499   CPPUNIT_ASSERT((*tmp7)[3]->getBoolValue());
 500   CPPUNIT_ASSERT( (*tmp7==*tmp8) );
 501   CPPUNIT_ASSERT( (*tmp7==*tmp7) );
 502   CPPUNIT_ASSERT( 8==tmp7->size() );
 503   CPPUNIT_ASSERT( 8==tmp8->size() );
 504   tmp8=ArrayAny::New(tab5,lgth-1);
 505   CPPUNIT_ASSERT( 7==tmp8->size() );
 506   CPPUNIT_ASSERT( !(*tmp7==*tmp8) );
 507   tmp8=ArrayAny::New(tab6,lgth);
 508   CPPUNIT_ASSERT( !(*tmp7==*tmp8) );
 509   tmp8=ArrayAny::New(tab5,lgth);
 510   CPPUNIT_ASSERT( (*tmp7==*tmp8) );
 511   ArrayAnyPtr tmp9=(ArrayAny *)tmp7->clone();
 512   CPPUNIT_ASSERT( (*tmp9==*tmp7) );
 513   CPPUNIT_ASSERT((*tmp8)[3]->getBoolValue());
 514   CPPUNIT_ASSERT(!(*tmp8)[4]->getBoolValue());
 515   //Ok let's test with strings.
 516   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";
 517   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";
 518   ArrayAnyPtr tmp10(ArrayAny::New(tab7));
 519   ArrayAnyPtr tmp11(ArrayAny::New(tab7));
 520   CPPUNIT_ASSERT((*tmp10)[3]->getStringValue()=="jkl");
 521   CPPUNIT_ASSERT( (*tmp10==*tmp11) );
 522   CPPUNIT_ASSERT( (*tmp10==*tmp10) );
 523   CPPUNIT_ASSERT( 8==tmp10->size() );
 524   CPPUNIT_ASSERT( 8==tmp11->size() );
 525   vector<string> tab9(tab7); tab9.pop_back();
 526   tmp11=ArrayAny::New(tab9);
 527   CPPUNIT_ASSERT( 7==tmp11->size() );
 528   CPPUNIT_ASSERT( !(*tmp10==*tmp11) );
 529   tmp11=ArrayAny::New(tab8);
 530   CPPUNIT_ASSERT( !(*tmp10==*tmp11) );
 531   tmp11=ArrayAny::New(tab7);
 532   CPPUNIT_ASSERT( (*tmp10==*tmp11) );
 533   ArrayAnyPtr tmp12=(ArrayAny *)tmp10->clone();
 534   CPPUNIT_ASSERT( (*tmp12==*tmp10) );
 535   CPPUNIT_ASSERT((*tmp11)[3]->getStringValue()=="jkl");
 536   CPPUNIT_ASSERT((*tmp11)[4]->getStringValue()=="mno");
 537 }
 538
 539 /*!
 540  * Test of ArrayAny on multi-levels. To test recursion.
 541  */
 542 void EngineTest::checkAny7()
 543 {
 544   const int lgth=8;
 545   const int tab1[lgth]={0,1,1,9,2,7,2,3};
 546   const int tab2[lgth]={7,8,8,16,9,14,9,10};
 547   //Testing Arrays of arrays
 548   ArrayAnyPtr tmp11(ArrayAny::New(tab1,lgth));
 549   ArrayAnyPtr tmp12(ArrayAny::New(tab2,lgth));
 550   ArrayAnyPtr tmp12Throw(ArrayAny::New(tab2,lgth+1));
 551   ArrayAnyPtr tmp2(ArrayAny::New(tmp11->getType(),2));
 552   tmp2->setEltAtRank(0,tmp11);
 553   CPPUNIT_ASSERT_THROW(tmp2->setEltAtRank(1,tmp12Throw),Exception);
 554   tmp2->setEltAtRank(1,tmp12);
 555   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 556   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 557   //    Show deep copy process of arrays
 558   AnyPtr tmp=AtomAny::New(49);
 559   tmp11->setEltAtRank(0,tmp);
 560   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 561   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 562   ArrayAnyPtr tmp2Cloned=(ArrayAny *)(tmp2->clone());
 563   CPPUNIT_ASSERT_EQUAL(0,(*tmp2Cloned)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2Cloned)[1][0]->getIntValue());
 564   CPPUNIT_ASSERT_EQUAL(9,(*tmp2Cloned)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2Cloned)[1][3]->getIntValue());
 565   CPPUNIT_ASSERT( *tmp2==*tmp2Cloned );
 566   CPPUNIT_ASSERT( *tmp2==*tmp2 );
 567   //Testing Array of Sequences
 568   SequenceAnyPtr tmp13(SequenceAny::New((int *)tab1,lgth,0));
 569   SequenceAnyPtr tmp14(SequenceAny::New((int *)tab2,lgth,0));
 570   tmp2=ArrayAny::New(tmp13->getType(),2);
 571   tmp2->setEltAtRank(0,tmp13);
 572   tmp2->setEltAtRank(1,tmp14);
 573   CPPUNIT_ASSERT_EQUAL(0,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 574   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 575   tmp13->setEltAtRank(0,tmp);
 576   //    No deep copy here contrary to 14 lines ahead.
 577   CPPUNIT_ASSERT_EQUAL(49,(*tmp2)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2)[1][0]->getIntValue());
 578   CPPUNIT_ASSERT_EQUAL(9,(*tmp2)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2)[1][3]->getIntValue());
 579   tmp2Cloned=(ArrayAny *)(tmp2->clone());
 580   CPPUNIT_ASSERT_EQUAL(49,(*tmp2Cloned)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp2Cloned)[1][0]->getIntValue());
 581   CPPUNIT_ASSERT_EQUAL(9,(*tmp2Cloned)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp2Cloned)[1][3]->getIntValue());
 582   CPPUNIT_ASSERT( *tmp2==*tmp2Cloned );
 583   CPPUNIT_ASSERT( *tmp2==*tmp2 );
 584   //Testing Sequence of array
 585   tmp13=SequenceAny::New(tmp11->getType(),2);
 586   tmp13->setEltAtRank(0,tmp11);
 587   tmp13->setEltAtRank(1,tmp12);
 588   CPPUNIT_ASSERT_EQUAL(49,(*tmp13)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp13)[1][0]->getIntValue());
 589   CPPUNIT_ASSERT_EQUAL(9,(*tmp13)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp13)[1][3]->getIntValue());
 590   tmp14=(SequenceAny *)tmp13->clone();
 591   CPPUNIT_ASSERT_EQUAL(49,(*tmp14)[0][0]->getIntValue()); CPPUNIT_ASSERT_EQUAL(7,(*tmp14)[1][0]->getIntValue());
 592   CPPUNIT_ASSERT_EQUAL(9,(*tmp14)[0][3]->getIntValue()); CPPUNIT_ASSERT_EQUAL(16,(*tmp14)[1][3]->getIntValue());
 593   CPPUNIT_ASSERT( *tmp13==*tmp14 );
 594   CPPUNIT_ASSERT( *tmp13==*tmp13 );
 595 }
 596
 597 /*!
 598  * First test of structs.
 599  */
 600 void EngineTest::checkAny8()
 601 {
 602   TypeCodeStruct *tc=new TypeCodeStruct("","");
 603   tc->addMember("MyInt",Runtime::_tc_int);
 604   tc->addMember("MyDouble",Runtime::_tc_double);
 605   tc->addMember("MyBool",Runtime::_tc_bool);
 606   tc->addMember("MyStr",Runtime::_tc_string);
 607   StructAnyPtr tmp1=StructAny::New(tc);
 608   tmp1=StructAny::New(tc);
 609   AnyPtr tmpAtom=AtomAny::New(3791);
 610   tmp1->setEltAtRank("MyInt",tmpAtom);
 611   CPPUNIT_ASSERT_THROW(tmp1->setEltAtRank(1,tmpAtom),Exception);
 612   tmpAtom=AtomAny::New(3.14);
 613   CPPUNIT_ASSERT_THROW(tmp1->setEltAtRank("MyDoubl",tmpAtom),Exception);
 614   tmp1->setEltAtRank("MyDouble",tmpAtom);
 615   tmpAtom=AtomAny::New(false);
 616   tmp1->setEltAtRank("MyBool",tmpAtom);
 617   tmpAtom=AtomAny::New("abcdef");
 618   tmp1->setEltAtRank("MyStr",tmpAtom);
 619   CPPUNIT_ASSERT_EQUAL(3791,(*tmp1)["MyInt"]->getIntValue());
 620   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp1)["MyDouble"]->getDoubleValue(),1e-12);
 621   CPPUNIT_ASSERT_THROW((*tmp1)["MyIntT"],Exception);
 622   CPPUNIT_ASSERT(!(*tmp1)["MyBool"]->getBoolValue());
 623   CPPUNIT_ASSERT_THROW((*tmp1)["MyBool"]->getStringValue(),Exception);
 624   CPPUNIT_ASSERT((*tmp1)["MyStr"]->getStringValue()=="abcdef");
 625   tmpAtom=AtomAny::New("ghijklm");
 626   tmp1->setEltAtRank("MyStr",tmpAtom);
 627   CPPUNIT_ASSERT((*tmp1)["MyStr"]->getStringValue()=="ghijklm");
 628   //Introduce some recursive structure.
 629   SequenceAnyPtr tmp2=SequenceAny::New(tc,2);
 630   tmp2->setEltAtRank(0,tmp1);
 631   tmpAtom=AtomAny::New("opqrst");
 632   tmp1->setEltAtRank("MyStr",tmpAtom);
 633   tmp2->setEltAtRank(1,tmp1);
 634   CPPUNIT_ASSERT_EQUAL(3791,(*tmp2)[1]["MyInt"]->getIntValue());
 635   CPPUNIT_ASSERT((*tmp2)[0]["MyStr"]->getStringValue()=="ghijklm");
 636   CPPUNIT_ASSERT((*tmp2)[1]["MyStr"]->getStringValue()=="opqrst");
 637   CPPUNIT_ASSERT(*tmp2==*tmp2);
 638   AnyPtr tmp3=tmp2->clone();
 639   CPPUNIT_ASSERT(*tmp2==*tmp3);
 640   CPPUNIT_ASSERT((*tmp3)[0]["MyStr"]->getStringValue()=="ghijklm");
 641   CPPUNIT_ASSERT((*tmp3)[1]["MyStr"]->getStringValue()=="opqrst");
 642   tc->decrRef();
 643 }
 644
 645 void EngineTest::checkInGateOutGate()
 646 {
 647   string nodeName = "Node1";
 648   ElementaryNode* node1 = new TestElemNode(nodeName);
 649   _nodeMap[nodeName] = node1;
 650
 651   nodeName = "Node2";
 652   ElementaryNode* node2 = new TestElemNode(nodeName);
 653   _nodeMap[nodeName] = node2;
 654
 655   DEBTRACE(" --- check InGate OK after node creation" );
 656   {
 657     InGate *node1Ingate = node1->getInGate();
 658     CPPUNIT_ASSERT(node1Ingate);
 659     string name=node1Ingate->getNameOfTypeOfCurrentInstance();
 660     string expected="InGate";
 661     CPPUNIT_ASSERT_EQUAL(name,expected);
 662   }
 663
 664   DEBTRACE(" --- check OutGate OK after node creation" );
 665   {
 666     OutGate *node1Outgate = node1->getOutGate();
 667     CPPUNIT_ASSERT(node1Outgate);
 668     string name=node1Outgate->getNameOfTypeOfCurrentInstance();
 669     string expected="OutGate";
 670     CPPUNIT_ASSERT_EQUAL(name,expected);
 671   }
 672 }
 673
 674 void EngineTest::checkNodePortNumber()
 675 {
 676   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 677
 678   DEBTRACE(" --- check number of ports = 0 after node creation" );
 679   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 0);
 680   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 0);
 681
 682   InputPort  *in1 = node1->edAddInputPort("ib1",_tc_bool);
 683   InputPort  *in2 = node1->edAddInputPort("ii1",_tc_int);
 684   InputPort  *in3 = node1->edAddInputPort("ii2",_tc_int);
 685   InputPort  *in4 = node1->edAddInputPort("id1",_tc_double);
 686
 687   OutputPort *ou1 = node1->edAddOutputPort("ob1",_tc_bool);
 688   OutputPort *ou2 = node1->edAddOutputPort("oi1",_tc_int);
 689   OutputPort *ou3 = node1->edAddOutputPort("od1",_tc_double);
 690
 691   DEBTRACE(" --- check number of ports after ports creation" );
 692 //   DEBTRACE("     node1->getNumberOfInputPorts(): "
 693 //         << node1->getNumberOfInputPorts());
 694 //   DEBTRACE("     node1->getNumberOfOutputPorts(): "
 695 //         << node1->getNumberOfOutputPorts());
 696   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 4);
 697   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 698 }
 699
 700 void EngineTest::checkPortTypeName()
 701 {
 702   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 703
 704   DEBTRACE(" --- check InputPort name OK" );
 705   {
 706     string name=node1->getInputPort("ib1")->NAME;
 707     string expected="InputPort";
 708     CPPUNIT_ASSERT_EQUAL(name,expected);
 709   }
 710
 711   DEBTRACE(" --- check OutputPort name OK" );
 712   {
 713     string name=node1->getOutputPort("ob1")->NAME;
 714     string expected="OutputPort";
 715     CPPUNIT_ASSERT_EQUAL(name,expected);
 716   }
 717 }
 718
 719 void EngineTest::checkDuplicatePortName()
 720 {
 721   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 722   DEBTRACE(" --- check duplicated name throws exception" );
 723   CPPUNIT_ASSERT_THROW(InputPort *in5=node1->edAddInputPort("ii2",_tc_int),
 724                        YACS::Exception);
 725 }
 726
 727 void EngineTest::checkRemovePort()
 728 {
 729   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 730   ElementaryNode* node2 = (ElementaryNode*) _nodeMap["Node2"];
 731
 732     DEBTRACE(" --- check remove port" );
 733   {
 734     node1->edRemovePort(node1->getInputPort("ib1"));
 735     CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 3);
 736     CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 737   }
 738
 739   DEBTRACE(" --- check remove wrong port throws exception" )
 740   {
 741     CPPUNIT_ASSERT_THROW(node1->edRemovePort(node1->getInputPort("ib1")),
 742                          YACS::Exception);
 743   }
 744 }
 745
 746 void EngineTest::checkAddNodesToBloc()
 747 {
 748   DEBTRACE(" --- delete node; // ====== NOT OK : done by bloc" );
 749
 750   for (int i=0; i<10; i++)
 751     {
 752       ostringstream ss;
 753       ss << "Node_" << i;
 754       string s = ss.str();
 755       ElementaryNode* node = new TestElemNode(s);
 756       _nodeMap[s] = node;
 757       InputPort  *i1 = node->edAddInputPort("ib1",_tc_bool);
 758       InputPort  *i2 = node->edAddInputPort("ii1",_tc_int);
 759       InputPort  *i3 = node->edAddInputPort("ii2",_tc_int);
 760       InputPort  *i4 = node->edAddInputPort("id1",_tc_double);
 761       OutputPort *o1 = node->edAddOutputPort("ob1",_tc_bool);
 762       OutputPort *o2 = node->edAddOutputPort("oi1",_tc_int);
 763       OutputPort *o3 = node->edAddOutputPort("od1",_tc_double);
 764     }
 765
 766   DEBTRACE(" --- create bloc, add two nodes, check constituants" );
 767
 768   Bloc* bloc1 = new Bloc("bloc1");
 769   _nodeMap["bloc1"] = bloc1;
 770   _compoMap["bloc1"] = bloc1;
 771   bloc1->edAddChild(_nodeMap["Node_1"]);
 772   bloc1->edAddChild(_nodeMap["Node_2"]);
 773   {
 774     list<ElementaryNode *> setelem = bloc1->getRecursiveConstituents();
 775     CPPUNIT_ASSERT(setelem.size() == 2);
 776   }
 777 }
 778
 779 void EngineTest::checkAddingTwiceSameNodeInSameBloc()
 780 {
 781   DEBTRACE(" --- add the same node two times does nothing: return false" );
 782
 783   CPPUNIT_ASSERT(! ((Bloc*)_compoMap["bloc1"])->edAddChild(_nodeMap["Node_1"]));
 784 }
 785
 786 void EngineTest::checkAddingTwiceSameNodeInTwoBlocs()
 787 {
 788   DEBTRACE(" --- add a node already used elsewhere raises exception" );
 789
 790   Bloc* bloc2 = new Bloc("bloc2");
 791   _nodeMap["bloc2"] = bloc2;
 792   _compoMap["bloc2"] = bloc2;
 793   bloc2->edAddChild(_nodeMap["Node_3"]);
 794
 795   CPPUNIT_ASSERT_THROW(bloc2->edAddChild(_nodeMap["Node_1"]),
 796                        YACS::Exception);
 797 }
 798
 799
 800 void EngineTest::checkRecursiveBlocs_NumberOfNodes()
 801 {
 802   Bloc *bloc1 = (Bloc*)_compoMap["bloc1"];
 803   Bloc *bloc2 = (Bloc*)_compoMap["bloc2"];
 804
 805   DEBTRACE(" --- recursive blocs, check constituants" );
 806
 807   Bloc* bloc3 = new Bloc("bloc3");
 808   _nodeMap["bloc3"] = bloc3;
 809   _compoMap["bloc3"] = bloc3;
 810   bloc3->edAddChild((bloc1));  // 2 elementary nodes
 811   bloc3->edAddChild((bloc2));  // 1 elementary node
 812   bloc3->edAddChild(_nodeMap["Node_4"]);   // 1 elementary node
 813   {
 814     list<ElementaryNode *> setelem = bloc3->getRecursiveConstituents();
 815     CPPUNIT_ASSERT(setelem.size() == 4);
 816     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 817       {
 818         DEBTRACE("     elem name = " << (*it)->getName());
 819       }
 820   }
 821 }
 822
 823 void EngineTest::checkRecursiveBlocs_NumberOfPorts()
 824 {
 825   Bloc *bloc3 = (Bloc*)_compoMap["bloc3"];
 826
 827   DEBTRACE(" --- recursive blocs, check input & output ports // COMPLETER" );
 828   CPPUNIT_ASSERT(bloc3->getNumberOfInputPorts() == 4*4);
 829   DEBTRACE("     number of input ports: " << bloc3->getNumberOfInputPorts());
 830   DEBTRACE("     number of output ports: " << bloc3->getNumberOfOutputPorts());
 831   {
 832     list<InputPort *> inset = bloc3->getSetOfInputPort();
 833     list<OutputPort *> outset = bloc3->getSetOfOutputPort();
 834     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 835       {
 836         DEBTRACE("     input port name = " << bloc3->getInPortName(*it));
 837       }
 838     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 839       {
 840         DEBTRACE("     output port name = " << bloc3->getOutPortName(*it));
 841       }
 842   }
 843 }
 844
 845 void EngineTest::checkPortNameInBloc()
 846 {
 847
 848   DEBTRACE(" --- recursive blocs, check port names" );
 849
 850   InputPort *inport = _nodeMap["Node_1"]->getInputPort("id1");
 851   CPPUNIT_ASSERT(_nodeMap["bloc3"]->getInPortName(inport) == "bloc1.Node_1.id1");
 852   CPPUNIT_ASSERT(((Bloc*)_nodeMap["bloc3"])->getChildName(_nodeMap["Node_1"]) == "bloc1.Node_1");
 853 }
 854
 855 void EngineTest::checkGetNameOfPortNotInBloc()
 856 {
 857   InputPort *inport = _nodeMap["Node_5"]->getInputPort("id1");
 858   CPPUNIT_ASSERT_THROW(string name = _nodeMap["bloc3"]->getInPortName(inport),
 859                        YACS::Exception);
 860 }
 861
 862 void EngineTest::checkRemoveNode()
 863 {
 864   DEBTRACE(" --- bloc and port inventory must be OK after bloc remove" );
 865
 866   Bloc* bloc = new Bloc("blocR");
 867   _nodeMap["blocR"] = bloc;
 868   _compoMap["blocR"] = bloc;
 869   bloc->edAddChild(_nodeMap["Node_5"]);
 870   bloc->edAddChild(_nodeMap["Node_6"]);
 871   bloc->edAddChild(_nodeMap["Node_7"]);
 872
 873   {
 874     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 875     CPPUNIT_ASSERT(setelem.size() == 3);
 876
 877     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 878       {
 879         DEBTRACE("     elem name = " << (*it)->getName());
 880       }
 881   }
 882
 883   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_6"]);
 884
 885   {
 886     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 887     CPPUNIT_ASSERT(setelem.size() == 2);
 888     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 889       {
 890         DEBTRACE("     elem name         = " << (*it)->getName());
 891         DEBTRACE("     elem name in Bloc = " << ((Bloc *)_nodeMap["blocR"])->getChildName(*it));
 892       }
 893   }
 894
 895   {
 896     list<InputPort *> inset = _nodeMap["blocR"]->getSetOfInputPort();
 897     list<OutputPort *> outset = _nodeMap["blocR"]->getSetOfOutputPort();
 898     CPPUNIT_ASSERT(inset.size() == 8);
 899     CPPUNIT_ASSERT(outset.size() == 6);
 900     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 901       {
 902         DEBTRACE("     input port name for blocR  = " << _nodeMap["blocR"]->getInPortName(*it));
 903       }
 904     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 905       {
 906         DEBTRACE("     output port name for blocR  = " << _nodeMap["blocR"]->getOutPortName(*it));
 907       }
 908   }
 909
 910   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_5"]);
 911   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_7"]);
 912   {
 913     list<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 914     CPPUNIT_ASSERT(setelem.size() == 0);
 915   }
 916 }
 917
 918 void EngineTest::RecursiveBlocs_multipleRecursion()
 919 {
 920   {
 921     Bloc* bloc = new Bloc("bloc4");
 922     _nodeMap["bloc4"] = bloc;
 923     _compoMap["bloc4"] = bloc;
 924     bloc->edAddChild(_nodeMap["Node_5"]);
 925     bloc->edAddChild(_nodeMap["Node_6"]);
 926   }
 927
 928   {
 929     Bloc* bloc = new Bloc("bloc5");
 930     _nodeMap["bloc5"] = bloc;
 931     _compoMap["bloc5"] = bloc;
 932     bloc->edAddChild(_nodeMap["Node_7"]);
 933     bloc->edAddChild(_nodeMap["Node_8"]);
 934   }
 935
 936   {
 937     Bloc* bloc = new Bloc("bloc6");
 938     _nodeMap["bloc6"] = bloc;
 939     _compoMap["bloc6"] = bloc;
 940     bloc->edAddChild(_nodeMap["bloc4"]);
 941     bloc->edAddChild(_nodeMap["bloc5"]);
 942   }
 943
 944   {
 945     Bloc* bloc = new Bloc("bloc7");
 946     _nodeMap["bloc7"] = bloc;
 947     _compoMap["bloc7"] = bloc;
 948     bloc->edAddChild(_nodeMap["bloc3"]);
 949     bloc->edAddChild(_nodeMap["bloc6"]);
 950   }
 951
 952   {
 953     Bloc* bloc = new Bloc("graphe");
 954     _nodeMap["graphe"] = bloc;
 955     _compoMap["graphe"] = bloc;
 956     bloc->edAddChild(_nodeMap["bloc7"]);
 957     bloc->edAddChild(_nodeMap["Node_9"]);
 958   }
 959
 960   {
 961     list<ElementaryNode *> setelem = _nodeMap["graphe"]->getRecursiveConstituents();
 962     CPPUNIT_ASSERT(setelem.size() == 9);
 963     for (list<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 964       {
 965         DEBTRACE("     elem name = " << (*it)->getName());
 966       }
 967   }
 968
 969   {
 970     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
 971     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
 972     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 973       {
 974         DEBTRACE("     input port name for bloc7  = " << _nodeMap["bloc7"]->getInPortName(*it));
 975         DEBTRACE("     input port name for graphe = " << _nodeMap["graphe"]->getInPortName(*it));
 976       }
 977     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 978       {
 979         DEBTRACE("     output port name for bloc7  = " << _nodeMap["bloc7"]->getOutPortName(*it));
 980         DEBTRACE("     output port name for graphe = " << _nodeMap["graphe"]->getOutPortName(*it));
 981       }
 982     YACS::ENGINE::VisitorSaveState vst(_compoMap["graphe"]);
 983     vst.openFileDump("dumpState.xml");
 984     _compoMap["graphe"]->accept(&vst);
 985     vst.closeFileDump();
 986   }
 987 }
 988
 989 void EngineTest::RecursiveBlocs_removeNodes()
 990 {
 991 //   {
 992 //     set<Node *> setNodes = ((Bloc*)_nodeMap["graphe"])->getChildren();
 993 //     for (set<Node*>::iterator it=setNodes.begin(); it!=setNodes.end(); it++)
 994 //       {
 995 //      DEBTRACE("     child name = " << (*it)->getName());
 996 //       }
 997 //   }
 998
 999   {
1000     list<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
1001     CPPUNIT_ASSERT(setNode.size() == 16);
1002     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
1003     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
1004     DEBTRACE("     input port number in graph:  " <<inset.size());
1005     DEBTRACE("     output port number in graph: " <<outset.size());
1006     CPPUNIT_ASSERT(inset.size() == 32);
1007     CPPUNIT_ASSERT(outset.size() == 24);
1008   }
1009
1010   ((Bloc *)_nodeMap["bloc7"])->edRemoveChild(_nodeMap["bloc6"]);
1011
1012   {
1013     list<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
1014     CPPUNIT_ASSERT(setNode.size() == 9);
1015     for (list<Node*>::iterator it=setNode.begin(); it!=setNode.end(); it++)
1016       {
1017         DEBTRACE("     elem name = " << ((Bloc *)_nodeMap["graphe"])->getChildName(*it));
1018       }
1019     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
1020     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
1021     DEBTRACE("     input port number in graph:  " <<inset.size());
1022     DEBTRACE("     output port number in graph: " <<outset.size());
1023     CPPUNIT_ASSERT(inset.size() == 16);
1024     CPPUNIT_ASSERT(outset.size() == 12);
1025   }
1026
1027 }
1028
1029 void EngineTest::checkLogger()
1030 {
1031   Proc* proc=new Proc("proc");
1032   Logger* logger=proc->getLogger("parser");
1033   logger->error("error1","file.cxx",324);
1034   logger->error("error2","file.cxx",852);
1035   CPPUNIT_ASSERT(logger->hasErrors()==true);
1036   CPPUNIT_ASSERT(logger->isEmpty()==false);
1037   const char* expected1="LogRecord: parser:ERROR:error1 (file.cxx:324)\n"
1038                         "LogRecord: parser:ERROR:error2 (file.cxx:852)\n";
1039   CPPUNIT_ASSERT(logger->getStr()==expected1);
1040
1041   logger->reset();
1042   CPPUNIT_ASSERT(logger->hasErrors()==false);
1043   CPPUNIT_ASSERT(logger->isEmpty()==true);
1044
1045   logger->error("error1","file.cxx",324);
1046   logger->error("error2","file.cxx",852);
1047   logger->error("error3","file.cxx",978);
1048   CPPUNIT_ASSERT(logger->hasErrors()==true);
1049   CPPUNIT_ASSERT(logger->isEmpty()==false);
1050   const char* expected2="LogRecord: parser:ERROR:error1 (file.cxx:324)\n"
1051                         "LogRecord: parser:ERROR:error2 (file.cxx:852)\n"
1052                         "LogRecord: parser:ERROR:error3 (file.cxx:978)\n";
1053   CPPUNIT_ASSERT(logger->getStr()==expected2);
1054   delete proc;
1055 }