src/MEDMEM/Test/MEDMEMTest_MedMedDriver22.cxx

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