src/MEDMEMCppTest/MEDMEMTest_MedFieldDriver21.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_Field.hxx>
  26 #include <MEDMEM_MedFieldDriver21.hxx>
  27 #include "MEDMEM_MedMeshDriver.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 /*!
  36  *  Check methods (17), defined in MEDMEM_MedFieldDriver21.hxx:
  37  *  template <class T> class MED_FIELD_DRIVER21 : public virtual MED_FIELD_DRIVER<T> {
  38  *   (+) MED_FIELD_DRIVER21();
  39  *   (+) template <class INTERLACING_TAG> MED_FIELD_DRIVER21(const string & fileName,
  40  *          FIELD<T, INTERLACING_TAG> * ptrField, MED_EN::med_mode_acces accessMode);
  41  *   (+) MED_FIELD_DRIVER21(const MED_FIELD_DRIVER21 & fieldDriver);
  42  *   (+) virtual ~MED_FIELD_DRIVER21();
  43  *   (+) void open() throw (MEDEXCEPTION);
  44  *   (+) void close();
  45  *  }
  46  *  template <class T> class MED_FIELD_RDONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>,
  47  *                                                       public virtual IMED_FIELD_RDONLY_DRIVER<T> {
  48  *   (+) MED_FIELD_RDONLY_DRIVER21();
  49  *   (+) template <class INTERLACING_TAG> MED_FIELD_RDONLY_DRIVER21
  50  *                 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  51  *   (+) MED_FIELD_RDONLY_DRIVER21(const MED_FIELD_RDONLY_DRIVER21 & fieldDriver);
  52  *   (+) virtual ~MED_FIELD_RDONLY_DRIVER21();
  53  *   (+) void write(void) const throw (MEDEXCEPTION);
  54  *   (+) void read (void) throw (MEDEXCEPTION);
  55  *  }
  56  *  template <class T> class MED_FIELD_WRONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>,
  57  *                                                       public virtual IMED_FIELD_WRONLY_DRIVER<T> {
  58  *   (+) MED_FIELD_WRONLY_DRIVER21();
  59  *   (+) template <class INTERLACING_TAG> MED_FIELD_WRONLY_DRIVER21
  60  *              (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  61  *   (+) MED_FIELD_WRONLY_DRIVER21(const MED_FIELD_WRONLY_DRIVER21 & fieldDriver);
  62  *   (+) virtual ~MED_FIELD_WRONLY_DRIVER21();
  63  *   (+) void write(void) const throw (MEDEXCEPTION);
  64  *   (+) void read (void) throw (MEDEXCEPTION);
  65  *  }
  66  *  template <class T> class MED_FIELD_RDWR_DRIVER21 : public MED_FIELD_RDONLY_DRIVER21<T>,
  67  *                           public MED_FIELD_WRONLY_DRIVER21<T>, public IMED_FIELD_RDWR_DRIVER<T> {
  68  *   (+) MED_FIELD_RDWR_DRIVER21();
  69  *   (+) template <class INTERLACING_TAG> MED_FIELD_RDWR_DRIVER21
  70  *              (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  71  *   (+) MED_FIELD_RDWR_DRIVER21(const MED_FIELD_RDWR_DRIVER21 & fieldDriver);
  72  *   (+) ~MED_FIELD_RDWR_DRIVER21();
  73  *   (+) void write(void) const throw (MEDEXCEPTION);
  74  *   (+) void read (void) throw (MEDEXCEPTION);
  75  *  }
  76  */
  77 void MEDMEMTest::testMedFieldDriver21()
  78 {
  79   FIELD<int> *aField                = new FIELD<int> ();
  80   FIELD<int> *aField_1              = new FIELD<int> ();
  81   FIELD<double> *aField_2           = new FIELD<double> ();
  82   string data_dir                   = getenv("MED_ROOT_DIR");
  83   string tmp_dir                    = getenv("TMP") ? getenv("TMP") : "/tmp";
  84   if (tmp_dir == "")
  85     tmp_dir = "/tmp";
  86   string filename_rd                = data_dir + "/share/salome/resources/med/pointe.med";
  87   string filenameWithOutFileds      = data_dir + "/share/salome/resources/med/Mistrat.med";
  88   string fileldnotexist             = "anyfield";
  89   string fieldname                  = "fieldnodeint";
  90   string fieldname_cpy              = fieldname + "_cpy";
  91   string fileNotExist_rd            = "notExist.med";
  92   string emptyfilename              = "";
  93
  94   string filename_wr                = tmp_dir + "/myWrField_pointe21.med";
  95   string cp_file_wr                 = "cp " + filename_rd + " " + filename_wr;
  96   string fileNotExist_wr            = "/path_not_exist/file_not_exist.med";
  97   string emptyfile_wr               = tmp_dir + "/myWrField_pointe_empty21.med";
  98   string other_file                 = data_dir + "/share/salome/resources/med/fra.med";
  99   string other_file_wr              = tmp_dir + "/myWRfrab.med";
 100   string cp_other_file              = "cp " + other_file + " " + other_file_wr;
 101
 102   string filename_rdwr              = tmp_dir + "/myRdWrField_pointe21.med";
 103   string cp_file_rdwr               = "cp " + filename_rd + " " + filename_rdwr;
 104   string emptyfile_rdwr             = tmp_dir + "/myRdWrField_pointe_empty21.med";
 105   string fieldnameDouble            = "fieldcelldoublescalar";
 106   string fieldnameDouble_cpy        = fieldnameDouble + "_cpy";
 107
 108   // To remove tmp files from disk
 109   MEDMEMTest_TmpFilesRemover aRemover;
 110   aRemover.Register(filename_wr);
 111   aRemover.Register(emptyfile_wr);
 112   aRemover.Register(other_file_wr);
 113   aRemover.Register(filename_rdwr);
 114   aRemover.Register(emptyfile_rdwr);
 115
 116   //--------------------------Test READ ONLY part------------------------------//
 117
 118   /////////////////////////////////////
 119   //  TEST1: Open not existing file  //
 120   /////////////////////////////////////
 121
 122   //Creation Invalid Read Only MedFieldDriver21 (file not exist)
 123   MED_FIELD_RDONLY_DRIVER21<int> *aInvalidMedRdFieldDriver21_1 =
 124     new MED_FIELD_RDONLY_DRIVER21<int>(fileNotExist_rd, aField);
 125   //Trying open not existing file
 126   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver21_1->open(), MEDEXCEPTION);
 127
 128   //////////////////////////////////////////////
 129   //  TEST2: Open file with empty file name  ///
 130   //////////////////////////////////////////////
 131
 132   //Creation Invalid Read Only MedFieldDriver21 (empty file name)
 133   MED_FIELD_RDONLY_DRIVER21<int> *aInvalidMedRdFieldDriver21_2 =
 134     new MED_FIELD_RDONLY_DRIVER21<int>(emptyfilename, aField);
 135   //Trying file with empty name
 136   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver21_2->open(), MEDEXCEPTION);
 137
 138   /////////////////////////////////////////////////////
 139   //  TEST3: Reading field from file without fields  //
 140   /////////////////////////////////////////////////////
 141   MED_FIELD_RDONLY_DRIVER21<int> *aInvalidMedRdFieldDriver21_3 =
 142     new MED_FIELD_RDONLY_DRIVER21<int>(filenameWithOutFileds, aField);
 143   aInvalidMedRdFieldDriver21_3->open();
 144   aInvalidMedRdFieldDriver21_3->setFieldName(fieldname);
 145   //Trying read field from file
 146   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver21_3->read(), MEDEXCEPTION);
 147   aInvalidMedRdFieldDriver21_3->close();
 148
 149   ////////////////////////
 150   //  TEST4: Main test  //
 151   ////////////////////////
 152   //Creation correct Read Only MedFieldDriver21
 153   MED_FIELD_RDONLY_DRIVER21<int> *aMedRdFieldDriver21 =
 154     new MED_FIELD_RDONLY_DRIVER21<int>(filename_rd, aField);
 155
 156   //Check driver
 157   CPPUNIT_ASSERT(aMedRdFieldDriver21);
 158
 159   //Trying read field before open file
 160   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->read(),MEDEXCEPTION);
 161
 162   //Test open() method
 163   try
 164   {
 165     aMedRdFieldDriver21->open();
 166   }
 167   catch(MEDEXCEPTION &e)
 168   {
 169     CPPUNIT_FAIL(e.what());
 170   }
 171   catch( ... )
 172   {
 173     CPPUNIT_FAIL("Unknown exception");
 174   }
 175
 176   //#ifdef ENABLE_FORCED_FAILURES
 177   //Trying open file secondary.
 178   //CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->open(), MEDEXCEPTION);
 179         //  CPPUNIT_ASSERT_NO_THROW(aMedRdFieldDriver21->open());
 180   // (BUG) No exception in this case
 181   //#endif
 182
 183   //Trying read field form file if it name is empty
 184   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->read(), MEDEXCEPTION);
 185   //CPPUNIT_ASSERT_NO_THROW(aMedRdFieldDriver21->read(), MEDEXCEPTION);
 186
 187   //Test setFieldName() and getFieldName()
 188   try
 189   {
 190     aMedRdFieldDriver21->setFieldName(fileldnotexist);
 191   }
 192   catch(MEDEXCEPTION &e)
 193   {
 194     CPPUNIT_FAIL(e.what());
 195   }
 196   catch( ... )
 197   {
 198     CPPUNIT_FAIL("Unknown exception");
 199   }
 200   CPPUNIT_ASSERT_EQUAL(fileldnotexist, aMedRdFieldDriver21->getFieldName());
 201
 202   //Trying read not existing field from file
 203   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->read(), MEDEXCEPTION);
 204
 205   //Test read() method
 206   aMedRdFieldDriver21->setFieldName(fieldname);
 207   try
 208   {
 209     aMedRdFieldDriver21->read();
 210   }
 211   catch(MEDEXCEPTION &e)
 212   {
 213     CPPUNIT_FAIL(e.what());
 214   }
 215   catch( ... )
 216   {
 217     CPPUNIT_FAIL("Unknown exception");
 218   }
 219
 220   //Test write() method for READ ONLY driver
 221   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->write(), MEDEXCEPTION);
 222
 223   //Test close() method
 224   try
 225   {
 226     aMedRdFieldDriver21->close();
 227   }
 228   catch(MEDEXCEPTION &e)
 229   {
 230     CPPUNIT_FAIL(e.what());
 231   }
 232   catch( ... )
 233   {
 234     CPPUNIT_FAIL("Unknown exception");
 235   }
 236
 237   //Default constructor
 238   MED_FIELD_RDONLY_DRIVER21<int> aMedRdFieldDriver21Cpy_1;
 239
 240   //Test (void operator =) defined in GENDRIVER class in MEDMEM_GenDriver.hxx
 241   aMedRdFieldDriver21Cpy_1 = *aMedRdFieldDriver21;
 242
 243   //Test (bool operator ==) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 244   CPPUNIT_ASSERT(aMedRdFieldDriver21Cpy_1 ==  *aMedRdFieldDriver21);
 245
 246   //Test copy constructor
 247   MED_FIELD_RDONLY_DRIVER21<int> aMedRdFieldDriver21Cpy_2 (*aMedRdFieldDriver21);
 248   CPPUNIT_ASSERT_EQUAL(aMedRdFieldDriver21Cpy_2, *aMedRdFieldDriver21);
 249
 250   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 251   ostringstream rostr1, rostr2;
 252   rostr1<<aMedRdFieldDriver21Cpy_1;
 253   rostr2<<aMedRdFieldDriver21Cpy_2;
 254   CPPUNIT_ASSERT(rostr1.str() != "");
 255   CPPUNIT_ASSERT(rostr1.str() == rostr2.str());
 256
 257
 258   //--------------------------Test WRITE ONLY part------------------------------//
 259
 260   //Copy file
 261   //system(cp_other_file.c_str());
 262   system(cp_file_wr.c_str());
 263
 264   /////////////////////////////////////
 265   //  TEST1: Open not existing file  //
 266   /////////////////////////////////////
 267
 268   //Creation Invalid Write Only MedFieldDriver21 (file not exist)
 269   MED_FIELD_WRONLY_DRIVER21<int> *aInvalidMedWrFieldDriver21_1 =
 270     new MED_FIELD_WRONLY_DRIVER21<int>(fileNotExist_wr, aField_1);
 271   //Trying open not existing file
 272   CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver21_1->open(), MEDEXCEPTION);
 273
 274   /////////////////////////////////////////////
 275   //  TEST2: Open file with empty file name  //
 276   /////////////////////////////////////////////
 277   //Creation Invalid Write Only MedFieldDriver21 (empty file name)
 278   MED_FIELD_WRONLY_DRIVER21<int> *aInvalidMedWrFieldDriver21_2 =
 279     new MED_FIELD_WRONLY_DRIVER21<int>(emptyfilename, aField_1);
 280   //Trying open not existing file and file with empty name
 281   CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver21_2->open(), MEDEXCEPTION);
 282
 283   ///////////////////////////////////////////////////////
 284   //  TEST3: Writing field in empty file without mesh  // -- no problem
 285   ///////////////////////////////////////////////////////
 286   //Creation Write Only MedFieldDriver21
 287    MED_FIELD_WRONLY_DRIVER21<int> *aInvalidMedWrFieldDriver21_3 =
 288      new MED_FIELD_WRONLY_DRIVER21<int>(emptyfile_wr, aField);
 289
 290   aInvalidMedWrFieldDriver21_3->open();
 291   //#ifdef ENABLE_FAULTS
 292   CPPUNIT_ASSERT_NO_THROW(aInvalidMedWrFieldDriver21_3->write());
 293   //=>Segmentation fault in this case
 294   //#endif
 295
 296   //////////////////////////////////////////////
 297   //  TEST4: Writing field in the other file  //
 298   //////////////////////////////////////////////
 299
 300   //Creation Write Only MedFieldDriver21
 301   MED_FIELD_WRONLY_DRIVER21<int> *aInvalidMedWrFieldDriver21_4 =
 302     new MED_FIELD_WRONLY_DRIVER21<int>(other_file_wr, aField);
 303    aInvalidMedWrFieldDriver21_4->open();
 304   //#ifdef ENABLE_FAULTS
 305   CPPUNIT_ASSERT_NO_THROW(aInvalidMedWrFieldDriver21_4->write());
 306   aInvalidMedWrFieldDriver21_4->close();
 307   //=>Segmentation fault in this case
 308   //#endif
 309
 310   ////////////////////////
 311   //  TEST5: Main test  //
 312   ////////////////////////
 313
 314   //Creation correct Write Only MedFieldDriver21
 315   MED_FIELD_WRONLY_DRIVER21<int> *aMedWrFieldDriver21 =
 316     new MED_FIELD_WRONLY_DRIVER21<int>(filename_wr, aField);
 317
 318   //Check driver
 319   CPPUNIT_ASSERT(aMedWrFieldDriver21);
 320
 321   //Trying write field before open file
 322   //#ifdef ENABLE_FORCED_FAILURES
 323   CPPUNIT_ASSERT_THROW(aMedWrFieldDriver21->write(),MEDEXCEPTION);
 324   //CPPUNIT_ASSERT_NO_THROW(aMedWrFieldDriver21->write());
 325   // (BUG) No exception in this case
 326   //#endif
 327
 328   //Test open() method
 329   try
 330   {
 331     aMedWrFieldDriver21->open();
 332   }
 333   catch(MEDEXCEPTION &e)
 334   {
 335     CPPUNIT_FAIL(e.what());
 336   }
 337   catch( ... )
 338   {
 339     CPPUNIT_FAIL("Unknown exception");
 340   }
 341
 342   //#ifdef ENABLE_FORCED_FAILURES
 343   //Trying open file secondary.
 344   //CPPUNIT_ASSERT_THROW(aMedWrFieldDriver21->open(), MEDEXCEPTION);
 345   CPPUNIT_ASSERT_NO_THROW(aMedWrFieldDriver21->open());
 346   // (BUG) No exception in this case
 347   //#endif
 348
 349   //Test setFieldName() and getFieldName
 350   aField->setName(fieldname_cpy);
 351   try
 352   {
 353     aMedWrFieldDriver21->setFieldName(fieldname_cpy);
 354   }
 355   catch(MEDEXCEPTION &e)
 356   {
 357     CPPUNIT_FAIL(e.what());
 358   }
 359   catch( ... )
 360   {
 361     CPPUNIT_FAIL("Unknown exception");
 362   }
 363   CPPUNIT_ASSERT_EQUAL(fieldname_cpy, aMedWrFieldDriver21->getFieldName());
 364
 365   // there must be exception as mesh is not yet read
 366   // !!!!!!! mesh is not needed for writing !!!!!!!
 367   //CPPUNIT_ASSERT_THROW(aMedWrFieldDriver21->write(),MEDEXCEPTION);
 368
 369   try {
 370     aMedWrFieldDriver21->write();
 371
 372     MESH* aMesh = new MESH();
 373     aMesh->setName("maa1");
 374     MED_MESH_RDONLY_DRIVER aMeshDriver (filename_rd, aMesh);
 375     aMeshDriver.setMeshName("maa1");
 376     aMeshDriver.open();
 377     aMeshDriver.read();
 378     aMeshDriver.close();
 379     SUPPORT* sup = new SUPPORT(aMesh);
 380     aField->setSupport(sup);
 381   }
 382   catch(MEDEXCEPTION &e) {
 383     CPPUNIT_FAIL(e.what());
 384   }
 385   catch( ... ) {
 386     CPPUNIT_FAIL("Unknown exception");
 387   }
 388
 389   //MESH* mesh(MED_DRIVER,);
 390   //aMedWrFieldDriver21->getSupport()->setMesh(mesh);//read(),MEDEXCEPTION);
 391
 392   //#ifdef ENABLE_FAULTS
 393   //Test write() method
 394   try
 395   {
 396     aMedWrFieldDriver21->write();
 397   }
 398   catch(MEDEXCEPTION &e)
 399   {
 400     CPPUNIT_FAIL(e.what());
 401   }
 402   catch( ... )
 403   {
 404     CPPUNIT_FAIL("Unknown exception");
 405   }
 406   //=>Segmentation fault in this case
 407   //#endif
 408
 409   //Test read() method for Write only part
 410   CPPUNIT_ASSERT_THROW(aMedWrFieldDriver21->read(),MEDEXCEPTION);
 411
 412   //Test close() method
 413   try
 414   {
 415     aMedWrFieldDriver21->close();
 416   }
 417   catch(MEDEXCEPTION &e)
 418   {
 419     CPPUNIT_FAIL(e.what());
 420   }
 421   catch( ... )
 422   {
 423     CPPUNIT_FAIL("Unknown exception");
 424   }
 425
 426   //Default constructor
 427   MED_FIELD_WRONLY_DRIVER21<int> aMedWrFieldDriver21Cpy_1;
 428
 429   //Test (void operator =) defined in GENDRIVER class
 430   aMedWrFieldDriver21Cpy_1 = *aMedWrFieldDriver21;
 431
 432   //Test (bool operator ==) defined in GENDRIVER class
 433   CPPUNIT_ASSERT(aMedWrFieldDriver21Cpy_1.GENDRIVER::operator==(*aMedWrFieldDriver21));
 434
 435   //Test copy constructor
 436   MED_FIELD_WRONLY_DRIVER21<int> aMedWrFieldDriver21Cpy_2 (*aMedWrFieldDriver21);
 437   CPPUNIT_ASSERT_EQUAL(aMedWrFieldDriver21Cpy_2, *aMedWrFieldDriver21);
 438
 439   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 440   ostringstream wostr1, wostr2;
 441   wostr1 << aMedWrFieldDriver21Cpy_1;
 442   wostr2 << aMedWrFieldDriver21Cpy_2;
 443   CPPUNIT_ASSERT(wostr1.str() != "");
 444   CPPUNIT_ASSERT(wostr1.str() == wostr2.str());
 445
 446
 447   //--------------------------Test READ/WRITE part------------------------------//
 448
 449   //Copy files
 450   system(cp_file_rdwr.c_str());
 451   /////////////////////////////////////
 452   //  TEST1: Open not existing file  //
 453   /////////////////////////////////////
 454
 455   //Creation Invalid Read/Write MedFieldDriver21 (file not exist)
 456   MED_FIELD_RDWR_DRIVER21<int> *aInvalidMedRdWrFieldDriver21_1 =
 457     new MED_FIELD_RDWR_DRIVER21<int>(fileNotExist_wr, aField_1);
 458   //Trying open not existing file
 459   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver21_1->open(), MEDEXCEPTION);
 460
 461   /////////////////////////////////////////////
 462   //  TEST2: Open file with empty file name  //
 463   /////////////////////////////////////////////
 464   //Creation Invalid Read/Write MedFieldDriver21 (empty file name)
 465   MED_FIELD_RDWR_DRIVER21<int> *aInvalidMedRdWrFieldDriver21_2 =
 466     new MED_FIELD_RDWR_DRIVER21<int>(emptyfilename, aField_1);
 467   //Trying open not existing file and file with empty name
 468   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver21_2->open(), MEDEXCEPTION);
 469
 470   /////////////////////////////////////////////////////
 471   //  TEST3: Reading field from file without fields  //
 472   /////////////////////////////////////////////////////
 473   MED_FIELD_RDWR_DRIVER21<int> *aInvalidMedRdWrFieldDriver21_3 =
 474     new MED_FIELD_RDWR_DRIVER21<int>(filenameWithOutFileds, aField_1);
 475   aInvalidMedRdWrFieldDriver21_3->open();
 476   aInvalidMedRdWrFieldDriver21_3->setFieldName(fieldname);
 477   //Trying read field from file
 478   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver21_3->read(), MEDEXCEPTION);
 479   aInvalidMedRdWrFieldDriver21_3->close();
 480
 481   ///////////////////////////////////////////////////////
 482   //  TEST4: Writing field in empty file without mesh  //
 483   ///////////////////////////////////////////////////////
 484   //Creation Invalid Read/Write MedFieldDriver21
 485    MED_FIELD_RDWR_DRIVER21<int> *aInvalidMedRdWrFieldDriver21_4 =
 486      new MED_FIELD_RDWR_DRIVER21<int>(emptyfile_rdwr, aField);
 487
 488   aInvalidMedRdWrFieldDriver21_4->open();
 489   //#ifdef ENABLE_FAULTS
 490   //  CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver21_4->write(), MEDEXCEPTION);
 491   //=>Segmentation fault in this case
 492   //#endif
 493
 494         //VB : I don't quite understand the test, because, if the
 495         //file is already open, it is the open method that should fail.
 496         // as it is of little importance for the whole test base,
 497         //I remove it altogether
 498
 499 //   //////////////////////////////////////////////
 500 //   //  TEST6: Writing field in the other file  //
 501 //   //////////////////////////////////////////////
 502 //   //Creation Invalid Read/Write MedFieldDriver21
 503 //   MED_FIELD_RDWR_DRIVER21<int> *aInvalidMedRdWrFieldDriver21_5 =
 504 //     new MED_FIELD_RDWR_DRIVER21<int>(other_file_wr, aField);
 505 //   aInvalidMedRdWrFieldDriver21_5->open();
 506 //   //#ifdef ENABLE_FAULTS
 507 //   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver21_5->write(), MEDEXCEPTION);
 508 //   //=>Segmentation fault in this case
 509 //   //#endif
 510
 511   ////////////////////////
 512   //  TEST7: Main test  //
 513   ////////////////////////
 514
 515   //Creation correct Read/Write MedFieldDriver21
 516   MED_FIELD_RDWR_DRIVER21<double> *aMedRdWrFieldDriver21 =
 517     new MED_FIELD_RDWR_DRIVER21<double>(filename_rdwr, aField_2);
 518
 519   //Check driver
 520   CPPUNIT_ASSERT(aMedRdWrFieldDriver21);
 521
 522   //Trying read/write field before open file
 523   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver21->read(),MEDEXCEPTION);
 524   //#ifdef ENABLE_FORCED_FAILURES
 525   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver21->write(),MEDEXCEPTION);
 526   //(BUG) No exception in this case
 527   //#endif
 528
 529   //Test open() method
 530   try
 531   {
 532     aMedRdWrFieldDriver21->open();
 533   }
 534   catch(MEDEXCEPTION &e)
 535   {
 536     CPPUNIT_FAIL(e.what());
 537   }
 538   catch( ... )
 539   {
 540     CPPUNIT_FAIL("Unknown exception");
 541   }
 542
 543   //#ifdef ENABLE_FORCED_FAILURES
 544   //Trying open file secondary.
 545         //  CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver21->open(), MEDEXCEPTION);
 546   // (BUG) No exception in this case
 547   //#endif
 548
 549   //Trying read field from file if field name is empty
 550   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver21->read(), MEDEXCEPTION);
 551
 552   //Test setFieldName() and getFieldName
 553   try
 554   {
 555     aMedRdWrFieldDriver21->setFieldName(fileldnotexist);
 556   }
 557   catch(MEDEXCEPTION &e)
 558   {
 559     CPPUNIT_FAIL(e.what());
 560   }
 561   catch( ... )
 562   {
 563     CPPUNIT_FAIL("Unknown exception");
 564   }
 565   CPPUNIT_ASSERT_EQUAL(fileldnotexist, aMedRdWrFieldDriver21->getFieldName());
 566
 567   //Trying read not existing field from file
 568         // CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver21->read(), MEDEXCEPTION);
 569
 570   //Test read() method
 571
 572   aMedRdWrFieldDriver21->setFieldName(fieldnameDouble);
 573   aMedRdWrFieldDriver21->open();
 574   try
 575   {
 576     aMedRdWrFieldDriver21->read();
 577   }
 578   catch(MEDEXCEPTION &e)
 579   {
 580     CPPUNIT_FAIL(e.what());
 581   }
 582   catch( ... )
 583   {
 584     CPPUNIT_FAIL("Unknown exception");
 585   }
 586
 587   //Trying write field in the file with empty name
 588   aField_2->setName(emptyfilename);
 589   aMedRdWrFieldDriver21->setFieldName(emptyfilename);
 590   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver21->write(), MEDEXCEPTION);
 591
 592   //Test write() method
 593   aField_2->setName(fieldnameDouble_cpy);
 594   aMedRdWrFieldDriver21->setFieldName(fieldnameDouble_cpy);
 595   //#ifdef ENABLE_FAULTS
 596   try
 597   {
 598     aMedRdWrFieldDriver21->write();
 599   }
 600   catch(MEDEXCEPTION &e)
 601   {
 602     CPPUNIT_FAIL(e.what());
 603   }
 604   catch( ... )
 605   {
 606     CPPUNIT_FAIL("Unknown exception");
 607   }
 608   //=>Segmentation fault in this case
 609   //#endif
 610
 611   //Test close() method
 612   try
 613   {
 614     aMedRdWrFieldDriver21->close();
 615   }
 616   catch(MEDEXCEPTION &e)
 617   {
 618     CPPUNIT_FAIL(e.what());
 619   }
 620   catch( ... )
 621   {
 622     CPPUNIT_FAIL("Unknown exception");
 623   }
 624
 625   //Default constructor
 626   MED_FIELD_RDWR_DRIVER21<double> aMedRdWrFieldDriver21Cpy_1;
 627
 628   //Test (void operator =) defined in GENDRIVER class
 629   aMedRdWrFieldDriver21Cpy_1 = *aMedRdWrFieldDriver21;
 630
 631   //Test (bool operator ==) defined in GENDRIVER class
 632   CPPUNIT_ASSERT(aMedRdWrFieldDriver21Cpy_1.GENDRIVER::operator==(*aMedRdWrFieldDriver21));
 633
 634   //Test copy constructor
 635   MED_FIELD_RDWR_DRIVER21<double> aMedRdWrFieldDriver21Cpy_2 (*aMedRdWrFieldDriver21);
 636   CPPUNIT_ASSERT_EQUAL(aMedRdWrFieldDriver21Cpy_2, *aMedRdWrFieldDriver21);
 637
 638   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 639   ostringstream rwostr1, rwostr2;
 640   rwostr1 << aMedRdWrFieldDriver21Cpy_1;
 641   rwostr2 << aMedRdWrFieldDriver21Cpy_2;
 642   CPPUNIT_ASSERT(rwostr1.str() != "");
 643   CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 644
 645   //Delete all objects
 646   delete aField;
 647   delete aField_1;
 648   delete aField_2;
 649
 650   delete aInvalidMedRdFieldDriver21_1;
 651   delete aInvalidMedRdFieldDriver21_2;
 652   delete aInvalidMedRdFieldDriver21_3;
 653   delete aMedRdFieldDriver21;
 654
 655   delete aInvalidMedWrFieldDriver21_1;
 656   delete aInvalidMedWrFieldDriver21_2;
 657   delete aInvalidMedWrFieldDriver21_3;
 658   delete aInvalidMedWrFieldDriver21_4;
 659   delete aMedWrFieldDriver21;
 660
 661   delete aInvalidMedRdWrFieldDriver21_1;
 662   delete aInvalidMedRdWrFieldDriver21_2;
 663   delete aInvalidMedRdWrFieldDriver21_3;
 664   delete aInvalidMedRdWrFieldDriver21_4;
 665         //  delete aInvalidMedRdWrFieldDriver21_5;
 666   delete aMedRdWrFieldDriver21;
 667 }