src/engine/Test/engineTest.cxx

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