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 "ElementaryNode.hxx"
   6 #include "Loop.hxx"
   7 #include "Switch.hxx"
   8 #include "VisitorSaveState.hxx"
   9
  10 #include "SharedPtr.hxx"
  11 #include "RuntimeForEngineTest.hxx"
  12
  13 #include "engineTest.hxx"
  14
  15 #include <iostream>
  16 #include <sstream>
  17 #include <string>
  18 #include <list>
  19 #include <vector>
  20
  21 //#define _DEVDEBUG_
  22 #include "YacsTrace.hxx"
  23
  24 using namespace YACS::ENGINE;
  25 using namespace YACS;
  26 using namespace std;
  27
  28 map<string, Node*> EngineTest::_nodeMap;
  29 map<string, ComposedNode*> EngineTest::_compoMap;
  30
  31 // --- init typecodes
  32
  33 TypeCode *EngineTest::_tc_bool   = new TypeCode(Bool);
  34 TypeCode *EngineTest::_tc_int    = new TypeCode(Int);
  35 TypeCode *EngineTest::_tc_double = new TypeCode(Double);
  36
  37
  38 void EngineTest::setUp()
  39 {
  40 }
  41
  42 void EngineTest::tearDown()
  43 {
  44 }
  45
  46 void EngineTest::cleanUp()
  47 {
  48   map<string, ComposedNode*>::iterator iter2,iter3;
  49   for(map<string, Node*>::iterator iter=_nodeMap.begin();iter!=_nodeMap.end();iter++)
  50     if((*iter).second->getFather()==0)
  51       delete (*iter).second;
  52 }
  53
  54 void EngineTest::checkGetRuntime()
  55 {
  56   CPPUNIT_ASSERT_THROW(Runtime *myrun = getRuntime(), YACS::Exception);
  57   RuntimeForEngineTest::setRuntime();
  58   Runtime *myrun1 = getRuntime();
  59   CPPUNIT_ASSERT(myrun1);
  60   Runtime *myrun2 = getRuntime();
  61   CPPUNIT_ASSERT_EQUAL(myrun1, myrun2);
  62   }
  63
  64 void toto2(void *t)
  65 {
  66   delete [] (char *)t;
  67 }
  68
  69 void toto3(void *t)
  70 {
  71   delete [] (int *)t;
  72 }
  73
  74 void EngineTest::checkAny1()
  75 {
  76   char *toto=new char[10];
  77   strcpy(toto,"lkjlkj");
  78   Any *tmp=AtomAny::New(toto,toto2);//no copy here
  79   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  80   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  81   tmp->incrRef();
  82   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  83   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  84   tmp->decrRef();
  85   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  86   CPPUNIT_ASSERT( tmp->getStringValue() == "lkjlkj");
  87   tmp->decrRef();
  88   tmp=AtomAny::New("coucou",0);
  89   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
  90   CPPUNIT_ASSERT( tmp->getStringValue() == "coucou");
  91   tmp->decrRef();
  92   tmp=AtomAny::New(string("abcdef"));
  93   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
  94   CPPUNIT_ASSERT( tmp->getStringValue() == "abcdef");
  95   tmp->decrRef();
  96   tmp=AtomAny::New("ghijk");
  97   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
  98   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
  99   tmp->decrRef();
 100   tmp=AtomAny::New((char *)"ghijk");
 101   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 102   CPPUNIT_ASSERT( tmp->getStringValue() == "ghijk");
 103   tmp->decrRef();
 104 }
 105
 106 class A7
 107 {
 108 private:
 109   double _d;
 110   int _cnt;
 111 public:
 112   A7(double toto):_d(toto),_cnt(1) { }
 113   static A7 *New(double toto) { return new A7(toto); }
 114   double getToto() const { return _d; }
 115   void setToto(double val) { _d=val; }
 116   void incrRef() { _cnt++; }
 117   void decrRef();
 118 private:
 119   ~A7() { }
 120 };
 121
 122 void A7::decrRef()
 123 {
 124   if(--_cnt==0)
 125     delete this;
 126 }
 127
 128
 129 void checkSharedPtrFct2(const A7& a)
 130 {
 131   a.getToto();
 132 }
 133
 134 void checkSharedPtrFct1(const SharedPtr<A7>& a)
 135 {
 136   checkSharedPtrFct2(a);
 137 }
 138
 139
 140 void EngineTest::checkSharedPtr()
 141 {
 142   SharedPtr<A7> titi=A7::New(5.);
 143   SharedPtr<A7> toto=A7::New(5.1);
 144   SharedPtr<A7> tutu(toto);
 145   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.,titi->getToto(),1e-12);
 146   titi->setToto(7.1);
 147   CPPUNIT_ASSERT_DOUBLES_EQUAL(7.1,titi->getToto(),1e-12);
 148   checkSharedPtrFct2(titi);
 149   checkSharedPtrFct2(toto);
 150   titi=toto;
 151   checkSharedPtrFct2(titi);
 152   checkSharedPtrFct2(tutu);
 153 }
 154
 155 void EngineTest::checkAny2()
 156 {
 157   double tabStack[8]={1.2, 3.4, 5.6, 7.8, 9.0, 2.3, 4.5, 6.7};
 158   double *tabHeap=new double[8];
 159   memcpy(tabHeap,tabStack,8*sizeof(double));
 160   SequenceAnyPtr tmp(SequenceAny::New(tabStack,8,0));
 161   CPPUNIT_ASSERT_EQUAL(8,(int)tmp->size());
 162   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 163   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 164   AtomAnyPtr tmp2(AtomAny::New(8.9));
 165   tmp->pushBack(tmp2);
 166   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 167   tmp2=AtomAny::New(10.2);
 168   tmp->pushBack(tmp2);
 169   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 170   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 171   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.2,(*tmp)[9]->getDoubleValue(),1e-12);
 172   tmp->popBack();
 173   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 174   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 175   tmp2=AtomAny::New(10.3);
 176   tmp->pushBack(tmp2);
 177   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 178   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.9,(*tmp)[8]->getDoubleValue(),1e-12);
 179   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.3,(*tmp)[9]->getDoubleValue(),1e-12);
 180   tmp=SequenceAny::New(tabHeap,8,toto2);
 181   CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,(*tmp)[2]->getDoubleValue(),1e-12);
 182   CPPUNIT_ASSERT_DOUBLES_EQUAL(6.7,(*tmp)[7]->getDoubleValue(),1e-12);
 183   tmp2=AtomAny::New(8.5);
 184   tmp->pushBack(tmp2);
 185   tmp2=AtomAny::New(10.27);
 186   tmp->pushBack(tmp2);
 187   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 188   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.27,(*tmp)[9]->getDoubleValue(),1e-12);
 189   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 190   tmp->popBack();
 191   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 192   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 193   tmp2=AtomAny::New(10.445);
 194   tmp->pushBack(tmp2);
 195   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 196   CPPUNIT_ASSERT_DOUBLES_EQUAL(8.5,(*tmp)[8]->getDoubleValue(),1e-12);
 197   CPPUNIT_ASSERT_DOUBLES_EQUAL(10.445,(*tmp)[9]->getDoubleValue(),1e-12);
 198   // Idem but for int
 199   int tabStackI[8]={1, 3, 5, 7, 9, 2, 4, 6};
 200   int *tabHeapI=new int[8];
 201   memcpy(tabHeapI,tabStackI,8*sizeof(int));
 202   tmp=SequenceAny::New(tabStackI,8,0);
 203   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 204   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 205   tmp2=AtomAny::New(8);
 206   tmp->pushBack(tmp2);
 207   tmp2=AtomAny::New(25);
 208   tmp->pushBack(tmp2);
 209   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 210   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 211   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 212   CPPUNIT_ASSERT_EQUAL(25,(*tmp)[9]->getIntValue());
 213   //Same with no copy constructor
 214   tmp=SequenceAny::New(tabHeapI,8,toto3);
 215   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 216   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 217   tmp2=AtomAny::New(8);
 218   tmp->pushBack(tmp2);
 219   tmp2=AtomAny::New(27);
 220   tmp->pushBack(tmp2);
 221   CPPUNIT_ASSERT_EQUAL(5,(*tmp)[2]->getIntValue());
 222   CPPUNIT_ASSERT_EQUAL(6,(*tmp)[7]->getIntValue());
 223   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 224   CPPUNIT_ASSERT_EQUAL(27,(*tmp)[9]->getIntValue());
 225   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 226   tmp->popBack();
 227   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 228   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 229   tmp2=AtomAny::New(202);
 230   tmp->pushBack(tmp2);
 231   CPPUNIT_ASSERT_EQUAL(10,(int)tmp->size());
 232   CPPUNIT_ASSERT_EQUAL(8,(*tmp)[8]->getIntValue());
 233   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 234   try
 235     {
 236       double d=(*tmp)[2]->getDoubleValue();
 237       CPPUNIT_ASSERT(0);
 238     }
 239   catch(Exception& e)
 240     {
 241       CPPUNIT_ASSERT(std::string(e.what())=="Value is not a Double");
 242     }
 243   SequenceAnyPtr tmp3=SequenceAny::New(tmp->getType());
 244   try
 245     {
 246       tmp3->pushBack(tmp2);
 247       CPPUNIT_ASSERT(0);
 248     }
 249   catch(Exception& e)
 250     {
 251       CPPUNIT_ASSERT(std::string(e.what())=="Invalid runtime of YACS::Any struct : having Int and you want Sequence");
 252     }
 253   CPPUNIT_ASSERT_EQUAL(0,(int)tmp3->size());
 254   CPPUNIT_ASSERT_EQUAL(202,(*tmp)[9]->getIntValue());
 255   tmp3->pushBack(tmp);
 256   CPPUNIT_ASSERT_EQUAL(1,(int)tmp3->size());
 257   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 258   tmp=SequenceAny::New(tabStackI,8,0);
 259   tmp3->pushBack(tmp);
 260   CPPUNIT_ASSERT_EQUAL(2,(int)tmp3->size());
 261   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 262   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 263   tmp3->pushBack(tmp);
 264   tmp3->pushBack(tmp);
 265   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 266   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 267   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[1][3]->getIntValue());
 268   CPPUNIT_ASSERT_EQUAL(7,(*tmp3)[3][3]->getIntValue());
 269   tmp2=AtomAny::New(89);
 270   tmp->pushBack(tmp2);
 271   CPPUNIT_ASSERT_EQUAL(4,(int)tmp3->size());
 272   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 273   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 274   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 275   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 276   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[3][8]->getIntValue());
 277   tmp3->popBack();
 278   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 279   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 280   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 281   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 282   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[2][8]->getIntValue());
 283   SequenceAnyPtr tmp4=(SequenceAny *)tmp3->clone();
 284   CPPUNIT_ASSERT_EQUAL(3,(int)tmp4->size());
 285   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 286   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 287   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[2][8]->getIntValue());
 288   tmp4->popBack();
 289   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 290   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 291   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 292   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 293   CPPUNIT_ASSERT_EQUAL(89,(*tmp3)[1][8]->getIntValue());
 294   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 295   tmp->popBack();
 296   tmp2=AtomAny::New(107);
 297   tmp->pushBack(tmp2);
 298   CPPUNIT_ASSERT_EQUAL(2,(int)tmp4->size());
 299   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 300   CPPUNIT_ASSERT_EQUAL(202,(*tmp3)[0][9]->getIntValue());
 301   CPPUNIT_ASSERT_EQUAL(202,(*tmp4)[0][9]->getIntValue());
 302   CPPUNIT_ASSERT_EQUAL(107,(*tmp3)[1][8]->getIntValue());//These 2 lines to show that deepCpy has been done
 303   CPPUNIT_ASSERT_EQUAL(89,(*tmp4)[1][8]->getIntValue());
 304 }
 305
 306 void EngineTest::checkAny3()
 307 {
 308   vector<string> vec;
 309   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 310   SequenceAnyPtr tmp(SequenceAny::New(vec));
 311   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 312   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 313   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 314   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 315   tmp->pushBack(AtomAnyPtr(AtomAny::New("abcdefgh")));
 316   CPPUNIT_ASSERT_EQUAL(4,(int)tmp->size());
 317   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 318   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 319   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 320   CPPUNIT_ASSERT((*tmp)[3]->getStringValue()=="abcdefgh");
 321   tmp->popBack();
 322   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 323   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 324   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 325   CPPUNIT_ASSERT((*tmp)[2]->getStringValue()=="tutu");
 326   tmp->popBack();
 327   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 328   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 329   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="toto");
 330   tmp->popBack();
 331   CPPUNIT_ASSERT_EQUAL(1,(int)tmp->size());
 332   CPPUNIT_ASSERT((*tmp)[0]->getStringValue()=="tata00000");
 333   tmp->popBack();
 334   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 335   //
 336   vector<bool> vec2;
 337   tmp=SequenceAny::New(vec2);
 338   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 339   vec2.push_back(true); vec2.push_back(false); vec2.push_back(true); vec2.push_back(true); vec2.push_back(true);
 340   tmp=SequenceAny::New(vec2);
 341   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 342   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 343   //in perspective of SequenceAny of bool were optimized as std::vector<bool> does.
 344   tmp->pushBack(AtomAnyPtr(AtomAny::New(false))); tmp->pushBack(AtomAnyPtr(AtomAny::New(true))); tmp->pushBack(AtomAnyPtr(AtomAny::New(false)));
 345   tmp->pushBack(AtomAnyPtr(AtomAny::New(true)));
 346   CPPUNIT_ASSERT_EQUAL(9,(int)tmp->size());
 347   CPPUNIT_ASSERT((*tmp)[0]->getBoolValue() && !(*tmp)[1]->getBoolValue() && (*tmp)[2]->getBoolValue() && (*tmp)[3]->getBoolValue() && (*tmp)[4]->getBoolValue());
 348   CPPUNIT_ASSERT(!(*tmp)[5]->getBoolValue() && (*tmp)[6]->getBoolValue() && !(*tmp)[7]->getBoolValue() && (*tmp)[8]->getBoolValue());
 349   //
 350   vector<int> vec3;
 351   vec3.push_back(2); vec3.push_back(5); vec3.push_back(7); vec3.push_back(1); vec3.push_back(66); vec3.push_back(26);
 352   tmp=SequenceAny::New(vec3);
 353   CPPUNIT_ASSERT_EQUAL(6,(int)tmp->size());
 354   CPPUNIT_ASSERT_EQUAL(26,(*tmp)[5]->getIntValue());
 355   tmp->popBack();
 356   CPPUNIT_ASSERT_EQUAL(5,(int)tmp->size());
 357   //
 358   vector<double> vec4;
 359   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 360   tmp=SequenceAny::New(vec4);
 361   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 362   CPPUNIT_ASSERT_DOUBLES_EQUAL(0.07,(*tmp)[2]->getDoubleValue(),1e-12);
 363   tmp->popBack();
 364   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 365   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1]->getDoubleValue(),1e-12);
 366 }
 367
 368 void EngineTest::checkAny4()
 369 {
 370   SequenceAnyPtr tmp(SequenceAny::New(Runtime::_tc_int,8));
 371   tmp=SequenceAny::New(Runtime::_tc_int,4);
 372   tmp=SequenceAny::New(Runtime::_tc_int);
 373   tmp=SequenceAny::New(Runtime::_tc_int,7);
 374   AnyPtr tmp2=AtomAny::New(107);
 375   tmp->setEltAtRank(3,tmp2);
 376   CPPUNIT_ASSERT_EQUAL(107,(*tmp)[3]->getIntValue());
 377   tmp=SequenceAny::New(Runtime::_tc_string,2);
 378   tmp2=AtomAny::New("titi",0);
 379   tmp->setEltAtRank(1,tmp2);
 380   CPPUNIT_ASSERT((*tmp)[1]->getStringValue()=="titi");
 381   vector<double> vec4;
 382   vec4.push_back(2.78); vec4.push_back(3.14); vec4.push_back(0.07);
 383   tmp2=SequenceAny::New(vec4);
 384   tmp=SequenceAny::New(tmp2->getType(),3);
 385   tmp->setEltAtRank(0,tmp2);
 386   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[0][1]->getDoubleValue(),1e-12);
 387   CPPUNIT_ASSERT_EQUAL(3,(int)tmp->size());
 388   tmp->clear();
 389   CPPUNIT_ASSERT_EQUAL(0,(int)tmp->size());
 390   tmp->pushBack(tmp2);
 391   tmp->pushBack(tmp2);
 392   CPPUNIT_ASSERT_EQUAL(2,(int)tmp->size());
 393   CPPUNIT_ASSERT_DOUBLES_EQUAL(3.14,(*tmp)[1][1]->getDoubleValue(),1e-12);
 394 }
 395
 396 /*!
 397  * Testing Any::operator ==
 398  */
 399 void EngineTest::checkAny5()
 400 {
 401   //AtomAny
 402   AnyPtr tmp1=AtomAny::New(107);
 403   AnyPtr tmp2=AtomAny::New(107);
 404   CPPUNIT_ASSERT( *tmp1==*tmp2 );
 405   tmp1=AtomAny::New(106);
 406   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 407   CPPUNIT_ASSERT( ! (*tmp2==*tmp1) );
 408   tmp1=AtomAny::New("toto");
 409   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 410   tmp2=AtomAny::New("tot");
 411   CPPUNIT_ASSERT( ! (*tmp1==*tmp2) );
 412   tmp2=AtomAny::New("toto");
 413   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 414   tmp1=AtomAny::New("mmmmmlll");
 415   tmp2=tmp1->clone();
 416   CPPUNIT_ASSERT( (*tmp1==*tmp2) );
 417   //SequenceAny
 418   vector<string> vec;
 419   vec.push_back("tata00000"); vec.push_back("toto"); vec.push_back("tutu");
 420   SequenceAnyPtr tmp3=(SequenceAny::New(vec));
 421   CPPUNIT_ASSERT_EQUAL(3,(int)tmp3->size());
 422   CPPUNIT_ASSERT((*tmp3)[0]->getStringValue()=="tata00000");
 423   CPPUNIT_ASSERT((*tmp3)[1]->getStringValue()=="toto");
 424   CPPUNIT_ASSERT((*tmp3)[2]->getStringValue()=="tutu");
 425   AnyPtr tmp4=tmp3->clone();
 426   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 427   tmp3->popBack();
 428   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 429   tmp1=AtomAny::New("tutu");
 430   tmp3->pushBack(tmp1);
 431   CPPUNIT_ASSERT( (*tmp3==*tmp4) );
 432    tmp3->pushBack(tmp1);
 433   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 434   tmp3->popBack();
 435   CPPUNIT_ASSERT( *tmp3==*tmp4 );
 436   tmp3->popBack();
 437   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 438   tmp1=AtomAny::New("tutug");
 439   tmp3->pushBack(tmp1);
 440   CPPUNIT_ASSERT( !(*tmp3==*tmp4) );
 441 }
 442
 443 void EngineTest::checkInGateOutGate()
 444 {
 445   string nodeName = "Node1";
 446   ElementaryNode* node1 = new TestElemNode(nodeName);
 447   _nodeMap[nodeName] = node1;
 448
 449   nodeName = "Node2";
 450   ElementaryNode* node2 = new TestElemNode(nodeName);
 451   _nodeMap[nodeName] = node2;
 452
 453   DEBTRACE(" --- check InGate OK after node creation" );
 454   {
 455     InGate *node1Ingate = node1->getInGate();
 456     CPPUNIT_ASSERT(node1Ingate);
 457     string name=node1Ingate->getNameOfTypeOfCurrentInstance();
 458     string expected="InGate";
 459     CPPUNIT_ASSERT_EQUAL(name,expected);
 460   }
 461
 462   DEBTRACE(" --- check OutGate OK after node creation" );
 463   {
 464     OutGate *node1Outgate = node1->getOutGate();
 465     CPPUNIT_ASSERT(node1Outgate);
 466     string name=node1Outgate->getNameOfTypeOfCurrentInstance();
 467     string expected="OutGate";
 468     CPPUNIT_ASSERT_EQUAL(name,expected);
 469   }
 470 }
 471
 472 void EngineTest::checkNodePortNumber()
 473 {
 474   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 475
 476   DEBTRACE(" --- check number of ports = 0 after node creation" );
 477   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 0);
 478   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 0);
 479
 480   InputPort  *in1 = node1->edAddInputPort("ib1",_tc_bool);
 481   InputPort  *in2 = node1->edAddInputPort("ii1",_tc_int);
 482   InputPort  *in3 = node1->edAddInputPort("ii2",_tc_int);
 483   InputPort  *in4 = node1->edAddInputPort("id1",_tc_double);
 484
 485   OutputPort *ou1 = node1->edAddOutputPort("ob1",_tc_bool);
 486   OutputPort *ou2 = node1->edAddOutputPort("oi1",_tc_int);
 487   OutputPort *ou3 = node1->edAddOutputPort("od1",_tc_double);
 488
 489   DEBTRACE(" --- check number of ports after ports creation" );
 490 //   DEBTRACE("     node1->getNumberOfInputPorts(): "
 491 //         << node1->getNumberOfInputPorts());
 492 //   DEBTRACE("     node1->getNumberOfOutputPorts(): "
 493 //         << node1->getNumberOfOutputPorts());
 494   CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 4);
 495   CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 496 }
 497
 498 void EngineTest::checkPortTypeName()
 499 {
 500   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 501
 502   DEBTRACE(" --- check InputPort name OK" );
 503   {
 504     string name=node1->getInputPort("ib1")->NAME;
 505     string expected="InputPort";
 506     CPPUNIT_ASSERT_EQUAL(name,expected);
 507   }
 508
 509   DEBTRACE(" --- check OutputPort name OK" );
 510   {
 511     string name=node1->getOutputPort("ob1")->NAME;
 512     string expected="OutputPort";
 513     CPPUNIT_ASSERT_EQUAL(name,expected);
 514   }
 515 }
 516
 517 void EngineTest::checkDuplicatePortName()
 518 {
 519   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 520   DEBTRACE(" --- check duplicated name throws exception" );
 521   CPPUNIT_ASSERT_THROW(InputPort *in5=node1->edAddInputPort("ii2",_tc_int),
 522                        YACS::Exception);
 523 }
 524
 525 void EngineTest::checkRemovePort()
 526 {
 527   ElementaryNode* node1 = (ElementaryNode*) _nodeMap["Node1"];
 528   ElementaryNode* node2 = (ElementaryNode*) _nodeMap["Node2"];
 529
 530     DEBTRACE(" --- check remove port" );
 531   {
 532     node1->edRemovePort(node1->getInputPort("ib1"));
 533     CPPUNIT_ASSERT(node1->getNumberOfInputPorts() == 3);
 534     CPPUNIT_ASSERT(node1->getNumberOfOutputPorts() == 3);
 535   }
 536
 537   DEBTRACE(" --- check remove wrong port throws exception" )
 538   {
 539     CPPUNIT_ASSERT_THROW(node1->edRemovePort(node1->getInputPort("ib1")),
 540                          YACS::Exception);
 541   }
 542 }
 543
 544 void EngineTest::checkAddNodesToBloc()
 545 {
 546   DEBTRACE(" --- delete node; // ====== NOT OK : done by bloc" );
 547
 548   for (int i=0; i<10; i++)
 549     {
 550       ostringstream ss;
 551       ss << "Node_" << i;
 552       string s = ss.str();
 553       ElementaryNode* node = new TestElemNode(s);
 554       _nodeMap[s] = node;
 555       InputPort  *i1 = node->edAddInputPort("ib1",_tc_bool);
 556       InputPort  *i2 = node->edAddInputPort("ii1",_tc_int);
 557       InputPort  *i3 = node->edAddInputPort("ii2",_tc_int);
 558       InputPort  *i4 = node->edAddInputPort("id1",_tc_double);
 559       OutputPort *o1 = node->edAddOutputPort("ob1",_tc_bool);
 560       OutputPort *o2 = node->edAddOutputPort("oi1",_tc_int);
 561       OutputPort *o3 = node->edAddOutputPort("od1",_tc_double);
 562     }
 563
 564   DEBTRACE(" --- create bloc, add two nodes, check constituants" );
 565
 566   Bloc* bloc1 = new Bloc("bloc1");
 567   _nodeMap["bloc1"] = bloc1;
 568   _compoMap["bloc1"] = bloc1;
 569   bloc1->edAddChild(_nodeMap["Node_1"]);
 570   bloc1->edAddChild(_nodeMap["Node_2"]);
 571   {
 572     set<ElementaryNode *> setelem = bloc1->getRecursiveConstituents();
 573     CPPUNIT_ASSERT(setelem.size() == 2);
 574   }
 575 }
 576
 577 void EngineTest::checkAddingTwiceSameNodeInSameBloc()
 578 {
 579   DEBTRACE(" --- add the same node two times does nothing: return false" );
 580
 581   CPPUNIT_ASSERT(! ((Bloc*)_compoMap["bloc1"])->edAddChild(_nodeMap["Node_1"]));
 582 }
 583
 584 void EngineTest::checkAddingTwiceSameNodeInTwoBlocs()
 585 {
 586   DEBTRACE(" --- add a node already used elsewhere raises exception" );
 587
 588   Bloc* bloc2 = new Bloc("bloc2");
 589   _nodeMap["bloc2"] = bloc2;
 590   _compoMap["bloc2"] = bloc2;
 591   bloc2->edAddChild(_nodeMap["Node_3"]);
 592
 593   CPPUNIT_ASSERT_THROW(bloc2->edAddChild(_nodeMap["Node_1"]),
 594                        YACS::Exception);
 595 }
 596
 597
 598 void EngineTest::checkRecursiveBlocs_NumberOfNodes()
 599 {
 600   Bloc *bloc1 = (Bloc*)_compoMap["bloc1"];
 601   Bloc *bloc2 = (Bloc*)_compoMap["bloc2"];
 602
 603   DEBTRACE(" --- recursive blocs, check constituants" );
 604
 605   Bloc* bloc3 = new Bloc("bloc3");
 606   _nodeMap["bloc3"] = bloc3;
 607   _compoMap["bloc3"] = bloc3;
 608   bloc3->edAddChild((bloc1));  // 2 elementary nodes
 609   bloc3->edAddChild((bloc2));  // 1 elementary node
 610   bloc3->edAddChild(_nodeMap["Node_4"]);   // 1 elementary node
 611   {
 612     set<ElementaryNode *> setelem = bloc3->getRecursiveConstituents();
 613     CPPUNIT_ASSERT(setelem.size() == 4);
 614     for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 615       {
 616         DEBTRACE("     elem name = " << (*it)->getName());
 617       }
 618   }
 619 }
 620
 621 void EngineTest::checkRecursiveBlocs_NumberOfPorts()
 622 {
 623   Bloc *bloc3 = (Bloc*)_compoMap["bloc3"];
 624
 625   DEBTRACE(" --- recursive blocs, check input & output ports // COMPLETER" );
 626   CPPUNIT_ASSERT(bloc3->getNumberOfInputPorts() == 4*4);
 627   DEBTRACE("     number of input ports: " << bloc3->getNumberOfInputPorts());
 628   DEBTRACE("     number of output ports: " << bloc3->getNumberOfOutputPorts());
 629   {
 630     list<InputPort *> inset = bloc3->getSetOfInputPort();
 631     list<OutputPort *> outset = bloc3->getSetOfOutputPort();
 632     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 633       {
 634         DEBTRACE("     input port name = " << bloc3->getInPortName(*it));
 635       }
 636     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 637       {
 638         DEBTRACE("     output port name = " << bloc3->getOutPortName(*it));
 639       }
 640   }
 641 }
 642
 643 void EngineTest::checkPortNameInBloc()
 644 {
 645
 646   DEBTRACE(" --- recursive blocs, check port names" );
 647
 648   InputPort *inport = _nodeMap["Node_1"]->getInputPort("id1");
 649   CPPUNIT_ASSERT(_nodeMap["bloc3"]->getInPortName(inport) == "bloc1.Node_1.id1");
 650   CPPUNIT_ASSERT(((Bloc*)_nodeMap["bloc3"])->getChildName(_nodeMap["Node_1"]) == "bloc1.Node_1");
 651 }
 652
 653 void EngineTest::checkGetNameOfPortNotInBloc()
 654 {
 655   InputPort *inport = _nodeMap["Node_5"]->getInputPort("id1");
 656   CPPUNIT_ASSERT_THROW(string name = _nodeMap["bloc3"]->getInPortName(inport),
 657                        YACS::Exception);
 658 }
 659
 660 void EngineTest::checkRemoveNode()
 661 {
 662   DEBTRACE(" --- bloc and port inventory must be OK after bloc remove" );
 663
 664   Bloc* bloc = new Bloc("blocR");
 665   _nodeMap["blocR"] = bloc;
 666   _compoMap["blocR"] = bloc;
 667   bloc->edAddChild(_nodeMap["Node_5"]);
 668   bloc->edAddChild(_nodeMap["Node_6"]);
 669   bloc->edAddChild(_nodeMap["Node_7"]);
 670
 671   {
 672     set<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 673     CPPUNIT_ASSERT(setelem.size() == 3);
 674
 675     for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 676       {
 677         DEBTRACE("     elem name = " << (*it)->getName());
 678       }
 679   }
 680
 681   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_6"]);
 682
 683   {
 684     set<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 685     CPPUNIT_ASSERT(setelem.size() == 2);
 686     for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 687       {
 688         DEBTRACE("     elem name         = " << (*it)->getName());
 689         DEBTRACE("     elem name in Bloc = " << ((Bloc *)_nodeMap["blocR"])->getChildName(*it));
 690       }
 691   }
 692
 693   {
 694     list<InputPort *> inset = _nodeMap["blocR"]->getSetOfInputPort();
 695     list<OutputPort *> outset = _nodeMap["blocR"]->getSetOfOutputPort();
 696     CPPUNIT_ASSERT(inset.size() == 8);
 697     CPPUNIT_ASSERT(outset.size() == 6);
 698     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 699       {
 700         DEBTRACE("     input port name for blocR  = " << _nodeMap["blocR"]->getInPortName(*it));
 701       }
 702     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 703       {
 704         DEBTRACE("     output port name for blocR  = " << _nodeMap["blocR"]->getOutPortName(*it));
 705       }
 706   }
 707
 708   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_5"]);
 709   ((Bloc *)_nodeMap["blocR"])->edRemoveChild(_nodeMap["Node_7"]);
 710   {
 711     set<ElementaryNode *> setelem = _nodeMap["blocR"]->getRecursiveConstituents();
 712     CPPUNIT_ASSERT(setelem.size() == 0);
 713   }
 714 }
 715
 716 void EngineTest::RecursiveBlocs_multipleRecursion()
 717 {
 718   {
 719     Bloc* bloc = new Bloc("bloc4");
 720     _nodeMap["bloc4"] = bloc;
 721     _compoMap["bloc4"] = bloc;
 722     bloc->edAddChild(_nodeMap["Node_5"]);
 723     bloc->edAddChild(_nodeMap["Node_6"]);
 724   }
 725
 726   {
 727     Bloc* bloc = new Bloc("bloc5");
 728     _nodeMap["bloc5"] = bloc;
 729     _compoMap["bloc5"] = bloc;
 730     bloc->edAddChild(_nodeMap["Node_7"]);
 731     bloc->edAddChild(_nodeMap["Node_8"]);
 732   }
 733
 734   {
 735     Bloc* bloc = new Bloc("bloc6");
 736     _nodeMap["bloc6"] = bloc;
 737     _compoMap["bloc6"] = bloc;
 738     bloc->edAddChild(_nodeMap["bloc4"]);
 739     bloc->edAddChild(_nodeMap["bloc5"]);
 740   }
 741
 742   {
 743     Bloc* bloc = new Bloc("bloc7");
 744     _nodeMap["bloc7"] = bloc;
 745     _compoMap["bloc7"] = bloc;
 746     bloc->edAddChild(_nodeMap["bloc3"]);
 747     bloc->edAddChild(_nodeMap["bloc6"]);
 748   }
 749
 750   {
 751     Bloc* bloc = new Bloc("graphe");
 752     _nodeMap["graphe"] = bloc;
 753     _compoMap["graphe"] = bloc;
 754     bloc->edAddChild(_nodeMap["bloc7"]);
 755     bloc->edAddChild(_nodeMap["Node_9"]);
 756   }
 757
 758   {
 759     set<ElementaryNode *> setelem = _nodeMap["graphe"]->getRecursiveConstituents();
 760     CPPUNIT_ASSERT(setelem.size() == 9);
 761     for (set<ElementaryNode*>::iterator it=setelem.begin(); it!=setelem.end(); it++)
 762       {
 763         DEBTRACE("     elem name = " << (*it)->getName());
 764       }
 765   }
 766
 767   {
 768     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
 769     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
 770     for (list<InputPort *>::iterator it=inset.begin(); it!=inset.end(); it++)
 771       {
 772         DEBTRACE("     input port name for bloc7  = " << _nodeMap["bloc7"]->getInPortName(*it));
 773         DEBTRACE("     input port name for graphe = " << _nodeMap["graphe"]->getInPortName(*it));
 774       }
 775     for (list<OutputPort *>::iterator it=outset.begin(); it!=outset.end(); it++)
 776       {
 777         DEBTRACE("     output port name for bloc7  = " << _nodeMap["bloc7"]->getOutPortName(*it));
 778         DEBTRACE("     output port name for graphe = " << _nodeMap["graphe"]->getOutPortName(*it));
 779       }
 780     YACS::ENGINE::VisitorSaveState vst(_compoMap["graphe"]);
 781     vst.openFileDump("dumpState.xml");
 782     _compoMap["graphe"]->accept(&vst);
 783     vst.closeFileDump();
 784   }
 785 }
 786
 787 void EngineTest::RecursiveBlocs_removeNodes()
 788 {
 789 //   {
 790 //     set<Node *> setNodes = ((Bloc*)_nodeMap["graphe"])->getChildren();
 791 //     for (set<Node*>::iterator it=setNodes.begin(); it!=setNodes.end(); it++)
 792 //       {
 793 //      DEBTRACE("     child name = " << (*it)->getName());
 794 //       }
 795 //   }
 796
 797   {
 798     set<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
 799     CPPUNIT_ASSERT(setNode.size() == 16);
 800     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
 801     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
 802     DEBTRACE("     input port number in graph:  " <<inset.size());
 803     DEBTRACE("     output port number in graph: " <<outset.size());
 804     CPPUNIT_ASSERT(inset.size() == 32);
 805     CPPUNIT_ASSERT(outset.size() == 24);
 806   }
 807
 808   ((Bloc *)_nodeMap["bloc7"])->edRemoveChild(_nodeMap["bloc6"]);
 809
 810   {
 811     set<Node *> setNode = ((Bloc*)_nodeMap["graphe"])->getAllRecursiveConstituents();
 812     CPPUNIT_ASSERT(setNode.size() == 9);
 813     for (set<Node*>::iterator it=setNode.begin(); it!=setNode.end(); it++)
 814       {
 815         DEBTRACE("     elem name = " << ((Bloc *)_nodeMap["graphe"])->getChildName(*it));
 816       }
 817     list<InputPort *> inset = _nodeMap["bloc7"]->getSetOfInputPort();
 818     list<OutputPort *> outset = _nodeMap["bloc7"]->getSetOfOutputPort();
 819     DEBTRACE("     input port number in graph:  " <<inset.size());
 820     DEBTRACE("     output port number in graph: " <<outset.size());
 821     CPPUNIT_ASSERT(inset.size() == 16);
 822     CPPUNIT_ASSERT(outset.size() == 12);
 823   }
 824
 825 }