src/MEDMEMCppTest/MEDMEMTest_MedMedDriver21.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #include "MEDMEMTest.hxx"
  23 #include <cppunit/TestAssert.h>
  24
  25 #include <MEDMEM_Compatibility21_22.hxx>
  26 #include <MEDMEM_MedMedDriver21.hxx>
  27 #include <MEDMEM_Med.hxx>
  28
  29 // use this define to enable lines, execution of which leads to Segmentation Fault
  30 //#define ENABLE_FAULTS
  31
  32 // use this define to enable CPPUNIT asserts and fails, showing bugs
  33 //#define ENABLE_FORCED_FAILURES
  34
  35 using namespace std;
  36 using namespace MEDMEM;
  37 using namespace MED_EN;
  38
  39 /*!
  40  *  Check methods (21), defined in MEDMEM_MedMedDriver21.hxx:
  41  *  class MED_MED_DRIVER21 : public virtual MED_MED_DRIVER {
  42  *   (+) MED_MED_DRIVER21();
  43  *   (+) MED_MED_DRIVER21(const string & fileName,  MED * const ptrMed);
  44  *   (+) MED_MED_DRIVER21(const string & fileName,  MED * const ptrMed,
  45  *                            MED_EN::med_mode_acces accessMode);
  46  *   (+) MED_MED_DRIVER21(const MED_MED_DRIVER21 & driver);
  47  *   (+) virtual ~MED_MED_DRIVER21();
  48  *   (+) void open() throw (MEDEXCEPTION);
  49  *   (+) void close();
  50  *   (+) virtual void write          (void) const;
  51  *   (+) virtual void writeFrom      (void) const;
  52  *   (+) virtual void read           (void);
  53  *   (+) virtual void readFileStruct (void);
  54  *  }
  55  *  class MED_MED_RDONLY_DRIVER21 : public virtual IMED_MED_RDONLY_DRIVER,
  56  *                                  public virtual MED_MED_DRIVER21 {
  57  *   (+) MED_MED_RDONLY_DRIVER21();
  58  *   (+) MED_MED_RDONLY_DRIVER21(const string & fileName,  MED * const ptrMed);
  59  *   (+) MED_MED_RDONLY_DRIVER21(const MED_MED_RDONLY_DRIVER21 & driver);
  60  *   (+) virtual ~MED_MED_RDONLY_DRIVER21();
  61  *   (+) void write          (void) const throw (MEDEXCEPTION);
  62  *   (+) void writeFrom      (void) const throw (MEDEXCEPTION);
  63  *   (+) void read           (void) throw (MEDEXCEPTION);
  64  *   (+) void readFileStruct (void) throw (MEDEXCEPTION);
  65  *  }
  66  *  class MED_MED_WRONLY_DRIVER21 : public virtual IMED_MED_WRONLY_DRIVER,
  67  *                                  public virtual MED_MED_DRIVER21 {
  68  *   (+) MED_MED_WRONLY_DRIVER21();
  69  *   (+) MED_MED_WRONLY_DRIVER21(const string & fileName,  MED * const ptrMed);
  70  *   (+) MED_MED_WRONLY_DRIVER21(const MED_MED_WRONLY_DRIVER21 & driver);
  71  *   (+) virtual ~MED_MED_WRONLY_DRIVER21();
  72  *   (+) void write          (void) const throw (MEDEXCEPTION);
  73  *   (+) void writeFrom      (void) const throw (MEDEXCEPTION);
  74  *   (+) void read           (void) throw (MEDEXCEPTION);
  75  *   (+) void readFileStruct (void) throw (MEDEXCEPTION);
  76  *  }
  77  *  class MED_MED_RDWR_DRIVER21 : public MED_MED_RDONLY_DRIVER21,
  78  *                              public MED_MED_WRONLY_DRIVER21,
  79  *                              public IMED_MED_RDWR_DRIVER {
  80  *   (+) MED_MED_RDWR_DRIVER21();
  81  *   (+) MED_MED_RDWR_DRIVER21(const string & fileName,  MED * const ptrMed);
  82  *   (+) MED_MED_RDWR_DRIVER21(const MED_MED_RDWR_DRIVER21 & driver);
  83  *   (+) ~MED_MED_RDWR_DRIVER21();
  84  *   (+) void write          (void) const throw (MEDEXCEPTION);
  85  *   (+) void writeFrom      (void) const throw (MEDEXCEPTION);
  86  *   (+) void read           (void) throw (MEDEXCEPTION);
  87  *   (+) void readFileStruct (void) throw (MEDEXCEPTION);
  88  *  }
  89  */
  90 void MEDMEMTest::testMedMedDriver21() {
  91   MED *aMed                        = new MED();
  92   string data_dir                  = getenv("MED_ROOT_DIR");
  93   string tmp_dir                   = getenv("TMP") ? getenv("TMP") : "/tmp";
  94   if(tmp_dir == "")
  95     tmp_dir = "/tmp";
  96
  97   string filename_rd               = data_dir + "/share/salome/resources/med/pointe.med";
  98   string emptyfilename             = "";
  99   string filename_wr               = tmp_dir  + "/myMedWr_pointe21.med";
 100   string fileNotExistsName_rd      = "notExists.med";
 101   string fileNotExistsName_wr      = "/path_not_exists/file_not_exists.med";
 102   string filename_rdwr             = tmp_dir + "/myMedRdWr_pointe21.med";
 103   string fcopy                     = "cp " + filename_rd + " " + filename_rdwr;
 104
 105   // To remove tmp files from disk
 106   MEDMEMTest_TmpFilesRemover aRemover;
 107   aRemover.Register(filename_wr);
 108   aRemover.Register(filename_rdwr);
 109
 110   //Copy file in the TMP dir for testing READ/WRITE case
 111   system(fcopy.data());
 112
 113   //-------------------------------Test READ_ONLY part-------------------------------------------------------
 114   //Creation incorrect Med_Med read only driver (file is not exist)
 115   MED_MED_RDONLY_DRIVER21 *aInvalidMedMedRdDriver21 = new MED_MED_RDONLY_DRIVER21(fileNotExistsName_rd, aMed);
 116
 117   //Trying open not existing file
 118   CPPUNIT_ASSERT_THROW(aInvalidMedMedRdDriver21->open(),MEDEXCEPTION);
 119
 120   //Creation incorrect Med_Med read only driver (with empty file name)
 121   MED_MED_RDONLY_DRIVER21 *aInvalidMedMedRdDriver21_1 = new MED_MED_RDONLY_DRIVER21(emptyfilename, aMed);
 122
 123   //Trying open file with empty name
 124   CPPUNIT_ASSERT_THROW(aInvalidMedMedRdDriver21_1->open(),MEDEXCEPTION);
 125
 126
 127   //Creation a correct Med_Med read only driver (normal constructor)
 128   MED_MED_RDONLY_DRIVER21 *aMedMedRdDriver21 = new MED_MED_RDONLY_DRIVER21(filename_rd, aMed);
 129
 130   //Check driver
 131   CPPUNIT_ASSERT(aMedMedRdDriver21);
 132
 133   //Trying read mesh from file, if file is not open
 134   // !!!!!!!! Med driver does NOT NEED open() before read() but only before readFileStruct() !!!!
 135   //#ifdef  ENABLE_FORCED_FAILURES
 136   //CPPUNIT_ASSERT_THROW(aMedMedRdDriver21->read(), MEDEXCEPTION);
 137   //CPPUNIT_ASSERT_NO_THROW(aMedMedRdDriver21->read());
 138   // (BUG) No exception in this case.
 139   // so here everything is read
 140   //#endif
 141
 142   CPPUNIT_ASSERT_THROW(aMedMedRdDriver21->readFileStruct(),MEDEXCEPTION);
 143
 144   //Test open() method
 145   try
 146   {
 147     aMedMedRdDriver21->open();
 148   }
 149   catch(MEDEXCEPTION &e)
 150   {
 151     CPPUNIT_FAIL(e.what());
 152   }
 153   catch( ... )
 154   {
 155     CPPUNIT_FAIL("Unknown exception");
 156   }
 157
 158   //Trying open() file twice
 159   //#ifdef  ENABLE_FORCED_FAILURES
 160   //CPPUNIT_ASSERT_THROW(aMedMedRdDriver21->open(),MEDEXCEPTION);
 161   CPPUNIT_ASSERT_NO_THROW(aMedMedRdDriver21->open());
 162   //(BUG) No exception in this case.
 163   //#endif
 164
 165   //Test read() method
 166   try
 167   {
 168     aMedMedRdDriver21->read();
 169   }
 170   catch(MEDEXCEPTION &e)
 171   {
 172     CPPUNIT_FAIL(e.what());
 173   }
 174   catch( ... )
 175   {
 176     CPPUNIT_FAIL("Unknown exception");
 177   }
 178
 179   //Test read() method
 180   try
 181   {
 182     aMedMedRdDriver21->readFileStruct();
 183   }
 184   catch(MEDEXCEPTION &e)
 185   {
 186     CPPUNIT_FAIL(e.what());
 187   }
 188   catch( ... )
 189   {
 190     CPPUNIT_FAIL("Unknown exception");
 191   }
 192
 193   //Test write() and WriteFrom() methods for READ_ONLY part
 194   CPPUNIT_ASSERT_THROW(aMedMedRdDriver21->write(), MEDEXCEPTION);
 195   CPPUNIT_ASSERT_THROW(aMedMedRdDriver21->writeFrom(), MEDEXCEPTION);
 196
 197   //Check MED
 198   CPPUNIT_ASSERT(aMed);
 199
 200   //Test close() method
 201   try
 202   {
 203     aMedMedRdDriver21->close();
 204   }
 205   catch(MEDEXCEPTION &e)
 206   {
 207     CPPUNIT_FAIL(e.what());
 208   }
 209   catch( ... )
 210   {
 211     CPPUNIT_FAIL("Unknown exception");
 212   }
 213
 214   //Default constructor
 215   MED_MED_RDONLY_DRIVER21 aMedMedRdDriver21Cpy_1;
 216
 217   //Test (void operator =) defined in GENDRIVER class
 218   //aMedMedRdDriver21Cpy_1 = *aMedMedRdDriver21;
 219
 220   //Test copy constructor
 221   //#ifdef ENABLE_FAULTS
 222   MED_MED_RDONLY_DRIVER21 aMedMedRdDriver21Cpy_2 (*aMedMedRdDriver21);
 223   // (BUG) => Segmentation fault, because _concreteMedDrv is NULL
 224   // Process terminating with default action of signal 11 (SIGSEGV)
 225   //  Access not within mapped region at address 0x0
 226   //    at 0x34881A7A: MEDMEM::MED_MED_DRIVER::MED_MED_DRIVER(MEDMEM::MED_MED_DRIVER const&) (MEDMEM_MedMedDriver.cxx:56)
 227   //    by 0x34A07786: MEDMEM::MED_MED_RDONLY_DRIVER21::MED_MED_RDONLY_DRIVER21(MEDMEM::MED_MED_RDONLY_DRIVER21 const&) (MEDMEM_MedMedDriver21.cxx:179)
 228   //    by 0x343A02AD: MEDMEMTest::testMedMedDriver21() (MEDMEMTest_MedMedDriver21.cxx:219)
 229   //#endif
 230
 231   //CPPUNIT_ASSERT_EQUAL(aMedMedRdDriver21Cpy_2, *aMedMedRdDriver21);
 232
 233   //Test (bool operator ==) defined in GENDRIVER class in MEDMEM_GenDriver.hxx
 234   //CPPUNIT_ASSERT(aMedMedRdDriver21Cpy_2.GENDRIVER::operator==(*aMedMedRdDriver21));
 235
 236   //Test (friend ostream & operator <<) defined GENDRIVER class
 237   //ostringstream rwostr1, rwostr2;
 238   //rwostr1<<aMedMedRdDriver21Cpy_1;
 239   //rwostr2<<aMedMedRdDriver21Cpy_2;
 240   //CPPUNIT_ASSERT(rwostr1.str() != "");
 241   //CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 242
 243   //-------------------------------Test WRITE_ONLY part-------------------------------------------------------
 244   //Creation incorrect Med_Med write only driver (file is not exist)
 245   MED_MED_WRONLY_DRIVER21 *aInvalidMedMedWrDriver21 = new MED_MED_WRONLY_DRIVER21(fileNotExistsName_wr, aMed);
 246
 247   //Trying open not existing file
 248   CPPUNIT_ASSERT_THROW(aInvalidMedMedWrDriver21->open(),MEDEXCEPTION);
 249
 250   //Creation incorrect Med_Med write only driver (with empty file name)
 251   MED_MED_WRONLY_DRIVER21 *aInvalidMedMedWrDriver21_1 = new MED_MED_WRONLY_DRIVER21(emptyfilename, aMed);
 252
 253   //Trying open file with empty name
 254   CPPUNIT_ASSERT_THROW(aInvalidMedMedWrDriver21_1->open(),MEDEXCEPTION);
 255
 256
 257   //Creation a correct Med_Med write only driver (normal constructor)
 258   MED_MED_WRONLY_DRIVER21 *aMedMedWrDriver21 = new MED_MED_WRONLY_DRIVER21(filename_wr, aMed);
 259
 260   //Check driver
 261   CPPUNIT_ASSERT(aMedMedWrDriver21);
 262
 263
 264   //Trying write mesh to file, if file is not open
 265   // !!!!!!!! Med driver does NOT NEED open() before neither writeFrom() nor before write() !!!!
 266   //#ifdef ENABLE_FORCED_FAILURES
 267   //CPPUNIT_ASSERT_THROW(aMedMedWrDriver21->writeFrom(),MEDEXCEPTION);
 268   // (BUG) No exception in this case
 269   //#endif
 270
 271   //#ifdef  ENABLE_FAULTS
 272   //CPPUNIT_ASSERT_THROW(aMedMedWrDriver21->write(), MEDEXCEPTION);
 273   //(BUG) => Segmentation fault
 274   //#endif
 275
 276   //Test open() method
 277   try
 278   {
 279     // (not necessary)
 280     aMedMedWrDriver21->open();
 281   }
 282   catch(MEDEXCEPTION &e)
 283   {
 284     CPPUNIT_FAIL(e.what());
 285   }
 286   catch( ... )
 287   {
 288     CPPUNIT_FAIL("Unknown exception");
 289   }
 290
 291   //Trying open() file twice
 292   //#ifdef  ENABLE_FORCED_FAILURES
 293   CPPUNIT_ASSERT_NO_THROW(aMedMedWrDriver21->open());
 294   //(BUG) No exception in this case.
 295   //#endif
 296
 297   //Test writeFrom() method
 298   try
 299   {
 300     aMedMedWrDriver21->writeFrom();
 301   }
 302   catch(MEDEXCEPTION &e)
 303   {
 304     CPPUNIT_FAIL(e.what());
 305   }
 306   catch( ... )
 307   {
 308     CPPUNIT_FAIL("Unknown exception");
 309   }
 310
 311   //#ifdef ENABLE_FAULTS
 312   //Test write() method
 313   try
 314   {
 315     aMedMedWrDriver21->write();
 316   }
 317   catch(MEDEXCEPTION &e)
 318   {
 319     CPPUNIT_FAIL(e.what());
 320   }
 321   catch( ... )
 322   {
 323    CPPUNIT_FAIL("Unknown exception");
 324   }
 325   // (BUG) => terminate called after throwing an instance of 'std::length_error'
 326   // what():  basic_string::_S_create
 327   //#endif
 328
 329   //Test close method
 330   try
 331   {
 332     aMedMedWrDriver21->close();
 333   }
 334   catch(MEDEXCEPTION &e)
 335   {
 336     CPPUNIT_FAIL(e.what());
 337   }
 338   catch( ... )
 339   {
 340    CPPUNIT_FAIL("Unknown exception");
 341   }
 342
 343   //Default constructor
 344   MED_MED_WRONLY_DRIVER21 aMedMedWrDriver21Cpy_1;
 345
 346   //Test (void operator =) defined in GENDRIVER class
 347   //aMedMedWrDriver21Cpy_1 = *aMedMedWrDriver21;
 348
 349   //Test copy constructor
 350   //#ifdef ENABLE_FAULTS
 351   MED_MED_WRONLY_DRIVER21 aMedMedWrDriver21Cpy_2 (*aMedMedWrDriver21);
 352   // (BUG) => Segmentation fault
 353   //#endif
 354   //CPPUNIT_ASSERT_EQUAL(aMedMedWrDriver21Cpy_2, *aMedMedWrDriver21);
 355
 356   //Test (bool operator ==) defined in GENDRIVER class
 357   //CPPUNIT_ASSERT(aMedMedWrDriver21Cpy_2.GENDRIVER::operator==(*aMedMedWrDriver21));
 358
 359   //Test (friend ostream & operator <<) defined GENDRIVER class
 360   //ostringstream rwostr1, rwostr2;
 361   //rwostr1<<aMedMedWrDriver21Cpy_1;
 362   //rwostr2<<aMedMedWrDriver21Cpy_2;
 363   //CPPUNIT_ASSERT(rwostr1.str() != "");
 364   //CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 365
 366
 367 //-------------------------------Test READ/WRITE part-------------------------------------------------------
 368   //Creation incorrect Med_Med read/write driver (file is not exist)
 369   MED_MED_RDWR_DRIVER21 *aInvalidMedMedRdWrDriver21 = new MED_MED_RDWR_DRIVER21(fileNotExistsName_wr, aMed);
 370
 371   //Trying open not existing file
 372   CPPUNIT_ASSERT_THROW(aInvalidMedMedRdWrDriver21->open(),MEDEXCEPTION);
 373
 374   //Creation incorrect Med_Med read/write driver (with empty file name)
 375   MED_MED_RDWR_DRIVER21 *aInvalidMedMedRdWrDriver21_1 = new MED_MED_RDWR_DRIVER21(emptyfilename, aMed);
 376
 377   //Trying open file with empty name
 378   CPPUNIT_ASSERT_THROW(aInvalidMedMedRdWrDriver21_1->open(),MEDEXCEPTION);
 379
 380
 381   //Creation a correct Med_Med read/write driver (normal constructor)
 382   MED_MED_RDWR_DRIVER21 *aMedMedRdWrDriver21 = new MED_MED_RDWR_DRIVER21(filename_rdwr, aMed);
 383
 384   //Check driver
 385   CPPUNIT_ASSERT(aMedMedRdWrDriver21);
 386
 387   //Trying read MED from file if it is not open
 388   // !!!!!!!! Med driver does NOT NEED open() before read() but only before readFileStruct() !!!!
 389   //#ifdef  ENABLE_FORCED_FAILURES
 390   //CPPUNIT_ASSERT_THROW(aMedMedRdWrDriver21->read(), MEDEXCEPTION);
 391   // (BUG) No exception in this case.
 392   //#endif
 393
 394   CPPUNIT_ASSERT_THROW(aMedMedRdWrDriver21->readFileStruct(),MEDEXCEPTION);
 395
 396   //Trying write mesh to file, if file is not open
 397   // !!!!!!!! Med driver does NOT NEED open() before writeFrom() but only before write() !!!!
 398   //#ifdef ENABLE_FORCED_FAILURES
 399   //CPPUNIT_ASSERT_THROW(aMedMedRdWrDriver21->writeFrom(),MEDEXCEPTION);
 400   CPPUNIT_ASSERT_NO_THROW(aMedMedRdWrDriver21->writeFrom());
 401   // (BUG) => No exception in this case
 402   //#endif
 403
 404   //#ifdef ENABLE_FAULTS
 405   // !!!!!!! It does not throught since nothing has been yet read, so no attempts to write
 406   //CPPUNIT_ASSERT_THROW(aMedMedRdWrDriver21->write(),MEDEXCEPTION);
 407   CPPUNIT_ASSERT_NO_THROW(aMedMedRdWrDriver21->write());
 408   //(BUG) => Crash
 409   //#endif
 410
 411   //Test open() method
 412   try
 413   {
 414     aMedMedRdWrDriver21->open();
 415   }
 416   catch(MEDEXCEPTION &e)
 417   {
 418     CPPUNIT_FAIL(e.what());
 419   }
 420   catch( ... )
 421   {
 422     CPPUNIT_FAIL("Unknown exception");
 423   }
 424
 425   //Trying open() file twice
 426   //!!!! do not make troubles for the user
 427   //#ifdef  ENABLE_FORCED_FAILURES
 428   //CPPUNIT_ASSERT_THROW(aMedMedRdWrDriver21->open(),MEDEXCEPTION);
 429   //(BUG) No exception in this case.
 430   //#endif
 431
 432   //Test readFileStruct() method
 433     try
 434   {
 435     aMedMedRdWrDriver21->readFileStruct();
 436   }
 437   catch(MEDEXCEPTION &e)
 438   {
 439     CPPUNIT_FAIL(e.what());
 440   }
 441   catch( ... )
 442   {
 443     CPPUNIT_FAIL("Unknown exception");
 444   }
 445
 446   //Test read() method
 447   try
 448   {
 449     aMedMedRdWrDriver21->read();
 450   }
 451   catch(MEDEXCEPTION &e)
 452   {
 453     CPPUNIT_FAIL(e.what());
 454   }
 455   catch( ... )
 456   {
 457     CPPUNIT_FAIL("Unknown exception");
 458   }
 459
 460   //Test writeFrom() method
 461   try
 462   {
 463     aMedMedRdWrDriver21->writeFrom();
 464   }
 465   catch(MEDEXCEPTION &e)
 466   {
 467     CPPUNIT_FAIL(e.what());
 468   }
 469   catch( ... )
 470   {
 471     CPPUNIT_FAIL("Unknown exception");
 472   }
 473
 474   //#ifdef ENABLE_FAULTS
 475   //Test write() method
 476   try
 477   {
 478     aMedMedRdWrDriver21->write();
 479   }
 480   catch(MEDEXCEPTION &e)
 481   {
 482     CPPUNIT_FAIL(e.what());
 483   }
 484   catch( ... )
 485   {
 486     CPPUNIT_FAIL("Unknown exception");
 487   }
 488   //#endif
 489
 490   //Test close() method
 491   try
 492   {
 493     aMedMedRdWrDriver21->close();
 494   }
 495   catch(MEDEXCEPTION &e)
 496   {
 497     CPPUNIT_FAIL(e.what());
 498   }
 499   catch( ... )
 500   {
 501     CPPUNIT_FAIL("Unknown exception");
 502   }
 503
 504   //Default constructor
 505   MED_MED_RDWR_DRIVER21 aMedMedRdWrDriver21Cpy_1;
 506
 507   //Test copy constructor
 508   //#ifdef ENABLE_FAULTS
 509   MED_MED_RDWR_DRIVER21 aMedMedRdWrDriver21Cpy_2 (*aMedMedRdWrDriver21);
 510   // (BUG) => Segmentation fault
 511   //#endif
 512   //CPPUNIT_ASSERT_EQUAL(aMedMedRdWrDriver21Cpy_2, *aMedMedRdWrDriver21);
 513
 514   //Test (bool operator ==) defined in GENDRIVER class
 515   //CPPUNIT_ASSERT(aMedMedRdWrDriver21Cpy_2.GENDRIVER::operator==(*aMedMedRdWrDriver21));
 516
 517   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 518   //ostringstream rwostr1, rwostr2;
 519   //rwostr1<<aMedMedRdWrDriver21Cpy_1;
 520   //rwostr2<<aMedMedRdWrDriver21Cpy_2;
 521   //CPPUNIT_ASSERT(rwostr1.str() != "");
 522   //CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 523
 524   //Delete all objects
 525   delete aMed;
 526   delete aInvalidMedMedRdDriver21;
 527   delete aInvalidMedMedRdDriver21_1;
 528   delete aMedMedRdDriver21;
 529
 530   delete aInvalidMedMedWrDriver21;
 531   delete aInvalidMedMedWrDriver21_1;
 532   delete aMedMedWrDriver21;
 533
 534   delete aInvalidMedMedRdWrDriver21;
 535   delete aInvalidMedMedRdWrDriver21_1;
 536   delete aMedMedRdWrDriver21;
 537 }