src/MEDMEMCppTest/MEDMEMTest_MedFieldDriver.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
   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.
   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 "MEDMEMTest.hxx"
  21 #include <cppunit/TestAssert.h>
  22
  23 #include <MEDMEM_Field.hxx>
  24 #include <MEDMEM_MedFieldDriver.hxx>
  25
  26 // use this define to enable lines, execution of which leads to Segmentation Fault
  27 //#define ENABLE_FAULTS
  28
  29 // use this define to enable CPPUNIT asserts and fails, showing bugs
  30 //#define ENABLE_FORCED_FAILURES
  31
  32 /*!
  33  *  Check methods (17), defined in MEDMEM_MedFieldDriver22.hxx:
  34  *  template <class T> class MED_FIELD_DRIVER22 : public virtual MED_FIELD_DRIVER<T> {
  35  *   (+) MED_FIELD_DRIVER22();
  36  *   (+) template <class INTERLACING_TAG> MED_FIELD_DRIVER22(const string & fileName,
  37  *          FIELD<T, INTERLACING_TAG> * ptrField, MED_EN::med_mode_acces accessMode);
  38  *   (+) MED_FIELD_DRIVER22(const MED_FIELD_DRIVER22 & fieldDriver);
  39  *   (+) virtual ~MED_FIELD_DRIVER22();
  40  *   (+) void open() throw (MEDEXCEPTION);
  41  *   (+) void close();
  42  *  }
  43  *  template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER22<T>,
  44  *                                                       public virtual IMED_FIELD_RDONLY_DRIVER<T> {
  45  *   (+) MED_FIELD_RDONLY_DRIVER();
  46  *   (+) template <class INTERLACING_TAG> MED_FIELD_RDONLY_DRIVER
  47  *                 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  48  *   (+) MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver);
  49  *   (+) virtual ~MED_FIELD_RDONLY_DRIVER();
  50  *   (+) void write(void) const throw (MEDEXCEPTION);
  51  *   (+) void read (void) throw (MEDEXCEPTION);
  52  *  }
  53  *  template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER22<T>,
  54  *                                                       public virtual IMED_FIELD_WRONLY_DRIVER<T> {
  55  *   (+) MED_FIELD_WRONLY_DRIVER();
  56  *   (+) template <class INTERLACING_TAG> MED_FIELD_WRONLY_DRIVER
  57  *              (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  58  *   (+) MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver);
  59  *   (+) virtual ~MED_FIELD_WRONLY_DRIVER();
  60  *   (+) void write(void) const throw (MEDEXCEPTION);
  61  *   (+) void read (void) throw (MEDEXCEPTION);
  62  *  }
  63  *  template <class T> class MED_FIELD_RDWR_DRIVER22 : public MED_FIELD_RDONLY_DRIVER<T>,
  64  *                           public MED_FIELD_WRONLY_DRIVER<T>, public IMED_FIELD_RDWR_DRIVER<T> {
  65  *   (+) MED_FIELD_RDWR_DRIVER22();
  66  *   (+) template <class INTERLACING_TAG> MED_FIELD_RDWR_DRIVER22
  67  *              (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField);
  68  *   (+) MED_FIELD_RDWR_DRIVER22(const MED_FIELD_RDWR_DRIVER22 & fieldDriver);
  69  *   (+) ~MED_FIELD_RDWR_DRIVER22();
  70  *   (+) void write(void) const throw (MEDEXCEPTION);
  71  *   (+) void read (void) throw (MEDEXCEPTION);
  72  *  }
  73  */
  74 void MEDMEMTest::testMedFieldDriver()
  75 {
  76   FIELD<int> *aField                = new FIELD<int>();
  77   FIELD<int> *aField_1              = new FIELD<int>();
  78   FIELD<double> *aField_2           = new FIELD<double>();
  79   string filename_rd                = getResourceFile("pointe.med");
  80   string filenameWithOutFileds      = getResourceFile("mesh.med");
  81   string filenameWithOutFileds_rdwr = makeTmpFile("mesh.med", filenameWithOutFileds);
  82   string fileldnotexist             = "anyfield";
  83   string fieldname                  = "fieldnodeint";
  84   string fieldname_cpy              = fieldname + "_cpy";
  85   string fileNotExist_rd            = "notExist22.med";
  86   string emptyfilename              = "";
  87
  88   string filename_wr                = makeTmpFile("myWrField_pointe22.med", filename_rd);
  89   string fileNotExist_wr            = "/path_not_exist/file_not_exist.med";
  90   string emptyfile_wr               = makeTmpFile("myWrField_pointe_empty22.med");
  91   string other_file                 = getResourceFile("cube_hexa8.med");
  92   string other_file_wr              = makeTmpFile("myWRcube_hexa8.med", other_file);
  93
  94   string filename_rdwr              = makeTmpFile("myRdWrField_pointe22.med", filename_rd);
  95   string emptyfile_rdwr             = makeTmpFile("myRdWrField_pointe_empty22.med");
  96   string fieldnameDouble            = "fieldnodedouble";
  97   string fieldnameDouble_cpy        = fieldnameDouble + "_cpy";
  98
  99   // To remove tmp files from disk
 100   MEDMEMTest_TmpFilesRemover aRemover;
 101   aRemover.Register(filename_wr);
 102   aRemover.Register(emptyfile_wr);
 103   aRemover.Register(other_file_wr);
 104   aRemover.Register(filename_rdwr);
 105   aRemover.Register(emptyfile_rdwr);
 106   aRemover.Register(filenameWithOutFileds_rdwr);
 107
 108   //--------------------------Test READ ONLY part------------------------------//
 109
 110   /////////////////////////////////////
 111   //  TEST1: Open not existing file  //
 112   /////////////////////////////////////
 113
 114   //Creation Invalid Read Only MedFieldDriver22 (file not exist)
 115   MED_FIELD_RDONLY_DRIVER<int> *aInvalidMedRdFieldDriver22_1 =
 116     new MED_FIELD_RDONLY_DRIVER<int>(fileNotExist_rd, aField);
 117   //Trying open not existing file
 118   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver22_1->open(), MEDEXCEPTION);
 119
 120   //////////////////////////////////////////////
 121   //  TEST2: Open file with empty file name  ///
 122   //////////////////////////////////////////////
 123
 124   //Creation Invalid Read Only MedFieldDriver22 (empty file name)
 125   MED_FIELD_RDONLY_DRIVER<int> *aInvalidMedRdFieldDriver22_2 =
 126     new MED_FIELD_RDONLY_DRIVER<int>(emptyfilename, aField);
 127   //Trying file with empty name
 128   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver22_2->open(), MEDEXCEPTION);
 129
 130   /////////////////////////////////////////////////////
 131   //  TEST3: Reading field from file without fields  //
 132   /////////////////////////////////////////////////////
 133   MED_FIELD_RDONLY_DRIVER<int> *aInvalidMedRdFieldDriver22_3 =
 134     new MED_FIELD_RDONLY_DRIVER<int>(filenameWithOutFileds, aField);
 135   aInvalidMedRdFieldDriver22_3->open();
 136   aInvalidMedRdFieldDriver22_3->setFieldName(fieldname);
 137   //Trying read field from file
 138   CPPUNIT_ASSERT_THROW(aInvalidMedRdFieldDriver22_3->read(), MEDEXCEPTION);
 139   aInvalidMedRdFieldDriver22_3->close();
 140
 141   ////////////////////////
 142   //  TEST4: Main test  //
 143   ////////////////////////
 144   //Creation correct Read Only MedFieldDriver22
 145   MED_FIELD_RDONLY_DRIVER<int> *aMedRdFieldDriver22 =
 146     new MED_FIELD_RDONLY_DRIVER<int>(filename_rd, aField);
 147
 148   //Check driver
 149   CPPUNIT_ASSERT(aMedRdFieldDriver22);
 150
 151   //Trying read field before open file
 152   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->read(),MEDEXCEPTION);
 153
 154   //Test open() method
 155   try
 156   {
 157     aMedRdFieldDriver22->open();
 158   }
 159   catch(MEDEXCEPTION &e)
 160   {
 161     CPPUNIT_FAIL(e.what());
 162   }
 163   catch( ... )
 164   {
 165     CPPUNIT_FAIL("Unknown exception");
 166   }
 167
 168   //#ifdef ENABLE_FORCED_FAILURES
 169   //Trying open file secondary.
 170   //CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->open(), MEDEXCEPTION);
 171   CPPUNIT_ASSERT_NO_THROW(aMedRdFieldDriver22->open());
 172   // (BUG) No exception in this case
 173   //#endif
 174
 175   //Trying read field form file if it name is empty
 176   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->read(), MEDEXCEPTION);
 177
 178   //Test setFieldName() and getFieldName()
 179   try
 180   {
 181     aMedRdFieldDriver22->setFieldName(fileldnotexist);
 182   }
 183   catch(MEDEXCEPTION &e)
 184   {
 185     CPPUNIT_FAIL(e.what());
 186   }
 187   catch( ... )
 188   {
 189     CPPUNIT_FAIL("Unknown exception");
 190   }
 191   CPPUNIT_ASSERT_EQUAL(fileldnotexist, aMedRdFieldDriver22->getFieldName());
 192
 193   //Trying read not existing field from file
 194   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->read(), MEDEXCEPTION);
 195
 196   //Test read() method
 197   aMedRdFieldDriver22->setFieldName(fieldname);
 198   try
 199   {
 200     aMedRdFieldDriver22->read();
 201   }
 202   catch(MEDEXCEPTION &e)
 203   {
 204     CPPUNIT_FAIL(e.what());
 205   }
 206   catch( ... )
 207   {
 208     CPPUNIT_FAIL("Unknown exception");
 209   }
 210
 211   //Test write() method for READ ONLY driver
 212   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->write(), MEDEXCEPTION);
 213
 214   //Test close() method
 215   try
 216   {
 217     aMedRdFieldDriver22->close();
 218   }
 219   catch(MEDEXCEPTION &e)
 220   {
 221     CPPUNIT_FAIL(e.what());
 222   }
 223   catch( ... )
 224   {
 225     CPPUNIT_FAIL("Unknown exception");
 226   }
 227
 228   //Default constructor
 229   MED_FIELD_RDONLY_DRIVER<int> aMedRdFieldDriver22Cpy_1;
 230
 231   //Test (void operator =) defined in GENDRIVER class in MEDMEM_GenDriver.hxx
 232   aMedRdFieldDriver22Cpy_1 = *aMedRdFieldDriver22;
 233
 234   //Test (bool operator ==) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 235   CPPUNIT_ASSERT(aMedRdFieldDriver22Cpy_1 ==  *aMedRdFieldDriver22);
 236
 237   //Test copy constructorg
 238   MED_FIELD_RDONLY_DRIVER<int> aMedRdFieldDriver22Cpy_2 (*aMedRdFieldDriver22);
 239   CPPUNIT_ASSERT_EQUAL(aMedRdFieldDriver22Cpy_2, *aMedRdFieldDriver22);
 240
 241   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 242   ostringstream rostr1, rostr2;
 243   rostr1<<aMedRdFieldDriver22Cpy_1;
 244   rostr2<<aMedRdFieldDriver22Cpy_2;
 245   CPPUNIT_ASSERT(rostr1.str() != "");
 246   CPPUNIT_ASSERT(rostr1.str() == rostr2.str());
 247
 248
 249   //--------------------------Test WRITE ONLY part------------------------------//
 250
 251   /////////////////////////////////////
 252   //  TEST1: Open not existing file  //
 253   /////////////////////////////////////
 254
 255   //Creation Invalid Write Only MedFieldDriver22 (file not exist)
 256   MED_FIELD_WRONLY_DRIVER<int> *aInvalidMedWrFieldDriver22_1 =
 257     new MED_FIELD_WRONLY_DRIVER<int>(fileNotExist_wr, aField_1);
 258   //Trying open not existing file
 259   CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver22_1->open(), MEDEXCEPTION);
 260
 261   /////////////////////////////////////////////
 262   //  TEST2: Open file with empty file name  //
 263   /////////////////////////////////////////////
 264   //Creation Invalid Write Only MedFieldDriver22 (empty file name)
 265   MED_FIELD_WRONLY_DRIVER<int> *aInvalidMedWrFieldDriver22_2 =
 266     new MED_FIELD_WRONLY_DRIVER<int>(emptyfilename, aField_1);
 267   //Trying open not existing file and file with empty name
 268   CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver22_2->open(), MEDEXCEPTION);
 269
 270   ///////////////////////////////////////////////////////
 271   //  TEST3: Writing field in empty file without mesh  //
 272   ///////////////////////////////////////////////////////
 273   //Creation Invalid Write Only MedFieldDriver22
 274    MED_FIELD_WRONLY_DRIVER<int> *aInvalidMedWrFieldDriver22_3 =
 275      new MED_FIELD_WRONLY_DRIVER<int>(emptyfile_wr, aField);
 276
 277   aInvalidMedWrFieldDriver22_3->open();
 278   //#ifdef ENABLE_FORCED_FAILURES
 279   //CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver22_3->write(), MEDEXCEPTION);
 280   CPPUNIT_ASSERT_NO_THROW(aInvalidMedWrFieldDriver22_3->write());
 281   //(Bug) No Exception in this case
 282   aInvalidMedWrFieldDriver22_3->close();
 283   //#endif
 284
 285   //////////////////////////////////////////////
 286   //  TEST4: Writing field in the other file  //
 287   //////////////////////////////////////////////
 288
 289   //Creation Invalid Write Only MedFieldDriver22
 290   MED_FIELD_WRONLY_DRIVER<int> *aInvalidMedWrFieldDriver22_4 =
 291     new MED_FIELD_WRONLY_DRIVER<int>(other_file_wr, aField);
 292   aInvalidMedWrFieldDriver22_4->open();
 293   //#ifdef ENABLE_FORCED_FAILURES
 294   //CPPUNIT_ASSERT_THROW(aInvalidMedWrFieldDriver22_4->write(), MEDEXCEPTION);
 295   CPPUNIT_ASSERT_NO_THROW(aInvalidMedWrFieldDriver22_4->write());
 296   //(Bug) No Exception in this case
 297   //#endif
 298
 299   ////////////////////////
 300   //  TEST5: Main test  //
 301   ////////////////////////
 302
 303   //Creation correct Write Only MedFieldDriver22
 304   MED_FIELD_WRONLY_DRIVER<int> *aMedWrFieldDriver22 =
 305     new MED_FIELD_WRONLY_DRIVER<int>(filename_wr, aField);
 306
 307   //Check driver
 308   CPPUNIT_ASSERT(aMedWrFieldDriver22);
 309
 310   //Trying write field before open file
 311   //#ifdef ENABLE_FORCED_FAILURES
 312   CPPUNIT_ASSERT_THROW(aMedWrFieldDriver22->write(),MEDEXCEPTION);
 313   // (BUG) No exception in this case
 314   //#endif
 315
 316   //Test open() method
 317   try
 318   {
 319     aMedWrFieldDriver22->open();
 320   }
 321   catch(MEDEXCEPTION &e)
 322   {
 323     CPPUNIT_FAIL(e.what());
 324   }
 325   catch( ... )
 326   {
 327     CPPUNIT_FAIL("Unknown exception");
 328   }
 329
 330   //#ifdef ENABLE_FORCED_FAILURES
 331   //Trying open file secondary.
 332   //CPPUNIT_ASSERT_THROW(aMedWrFieldDriver22->open(), MEDEXCEPTION);
 333   CPPUNIT_ASSERT_NO_THROW(aMedWrFieldDriver22->open());
 334   // (BUG) No exception in this case
 335   //#endif
 336
 337   //Test setFieldName() and getFieldName
 338   aField->setName(fieldname_cpy);
 339   try
 340   {
 341     aMedWrFieldDriver22->setFieldName(fieldname_cpy);
 342   }
 343   catch(MEDEXCEPTION &e)
 344   {
 345     CPPUNIT_FAIL(e.what());
 346   }
 347   catch( ... )
 348   {
 349     CPPUNIT_FAIL("Unknown exception");
 350   }
 351   CPPUNIT_ASSERT_EQUAL(fieldname_cpy, aMedWrFieldDriver22->getFieldName());
 352
 353   //Test write() method
 354   try
 355   {
 356     aMedWrFieldDriver22->write();
 357   }
 358   catch(MEDEXCEPTION &e)
 359   {
 360     CPPUNIT_FAIL(e.what());
 361   }
 362   catch( ... )
 363   {
 364     CPPUNIT_FAIL("Unknown exception");
 365   }
 366
 367   //Test read() method for Write only part
 368   CPPUNIT_ASSERT_THROW(aMedWrFieldDriver22->read(),MEDEXCEPTION);
 369
 370   //Test close() method
 371   try
 372   {
 373     aMedWrFieldDriver22->close();
 374   }
 375   catch(MEDEXCEPTION &e)
 376   {
 377     CPPUNIT_FAIL(e.what());
 378   }
 379   catch( ... )
 380   {
 381     CPPUNIT_FAIL("Unknown exception");
 382   }
 383
 384   //Default constructor
 385   MED_FIELD_WRONLY_DRIVER<int> aMedWrFieldDriver22Cpy_1;
 386
 387   //Test (void operator =) defined in GENDRIVER class
 388   aMedWrFieldDriver22Cpy_1 = *aMedWrFieldDriver22;
 389
 390   //Test (bool operator ==) defined in GENDRIVER class
 391   CPPUNIT_ASSERT(aMedWrFieldDriver22Cpy_1.GENDRIVER::operator==(*aMedWrFieldDriver22));
 392
 393   //Test copy constructor
 394   MED_FIELD_WRONLY_DRIVER<int> aMedWrFieldDriver22Cpy_2 (*aMedWrFieldDriver22);
 395   CPPUNIT_ASSERT_EQUAL(aMedWrFieldDriver22Cpy_2, *aMedWrFieldDriver22);
 396
 397   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 398   ostringstream wostr1, wostr2;
 399   wostr1 << aMedWrFieldDriver22Cpy_1;
 400   wostr2 << aMedWrFieldDriver22Cpy_2;
 401   CPPUNIT_ASSERT(wostr1.str() != "");
 402   CPPUNIT_ASSERT(wostr1.str() == wostr2.str());
 403
 404
 405   //--------------------------Test READ/WRITE part------------------------------//
 406
 407   /////////////////////////////////////
 408   //  TEST1: Open not existing file  //
 409   /////////////////////////////////////
 410
 411   //Creation Invalid Read/Write MedFieldDriver22 (file not exist)
 412   MED_FIELD_RDWR_DRIVER<int> *aInvalidMedRdWrFieldDriver22_1 =
 413     new MED_FIELD_RDWR_DRIVER<int>(fileNotExist_wr, aField_1);
 414   //Trying open not existing file
 415   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver22_1->open(), MEDEXCEPTION);
 416
 417   /////////////////////////////////////////////
 418   //  TEST2: Open file with empty file name  //
 419   /////////////////////////////////////////////
 420   //Creation Invalid Read/Write MedFieldDriver22 (empty file name)
 421   MED_FIELD_RDWR_DRIVER<int> *aInvalidMedRdWrFieldDriver22_2 =
 422     new MED_FIELD_RDWR_DRIVER<int>(emptyfilename, aField_1);
 423   //Trying open not existing file and file with empty name
 424   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver22_2->open(), MEDEXCEPTION);
 425
 426   /////////////////////////////////////////////////////
 427   //  TEST3: Reading field from file without fields  //
 428   /////////////////////////////////////////////////////
 429   MED_FIELD_RDWR_DRIVER<int> *aInvalidMedRdWrFieldDriver22_3 =
 430     new MED_FIELD_RDWR_DRIVER<int>(filenameWithOutFileds_rdwr, aField_1);
 431   aInvalidMedRdWrFieldDriver22_3->open();
 432   aInvalidMedRdWrFieldDriver22_3->setFieldName(fieldname);
 433   //Trying read field from file
 434   CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver22_3->read(), MEDEXCEPTION);
 435   aInvalidMedRdWrFieldDriver22_3->close();
 436
 437   ///////////////////////////////////////////////////////
 438   //  TEST4: Writing field in empty file without mesh  //
 439   ///////////////////////////////////////////////////////
 440
 441   //Creation Invalid Read/Write MedFieldDriver22
 442    MED_FIELD_RDWR_DRIVER<int> *aInvalidMedRdWrFieldDriver22_4 =
 443      new MED_FIELD_RDWR_DRIVER<int>(emptyfile_rdwr, aField);
 444
 445   aInvalidMedRdWrFieldDriver22_4->open();
 446   //#ifdef ENABLE_FORCED_FAILURES
 447   //  CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver22_4->write(), MEDEXCEPTION);
 448   // (BUG) No exception in this case
 449   //#endif
 450
 451   //////////////////////////////////////////////
 452   //  TEST6: Writing field in the other file  //
 453   //////////////////////////////////////////////
 454
 455   //Creation Invalid Read/Write MedFieldDriver22
 456   MED_FIELD_RDWR_DRIVER<int> *aInvalidMedRdWrFieldDriver22_5 =
 457     new MED_FIELD_RDWR_DRIVER<int>(other_file_wr, aField);
 458   aInvalidMedRdWrFieldDriver22_5->open();
 459   //#ifdef ENABLE_FORCED_FAILURES
 460   //CPPUNIT_ASSERT_THROW(aInvalidMedRdWrFieldDriver22_5->write(), MEDEXCEPTION);
 461   // (BUG) No exception in this case
 462   //#endif
 463
 464   ////////////////////////
 465   //  TEST7: Main test  //
 466   ////////////////////////
 467
 468   //Creation correct Read/Write MedFieldDriver22
 469   MED_FIELD_RDWR_DRIVER<double> *aMedRdWrFieldDriver22 =
 470     new MED_FIELD_RDWR_DRIVER<double>(filename_rdwr, aField_2);
 471
 472   //Check driver
 473   CPPUNIT_ASSERT(aMedRdWrFieldDriver22);
 474
 475   //Trying read/write field before open file
 476   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver22->read(),MEDEXCEPTION);
 477   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver22->write(),MEDEXCEPTION);
 478
 479   //Test open() method
 480   try
 481   {
 482     aMedRdWrFieldDriver22->open();
 483   }
 484   catch(MEDEXCEPTION &e)
 485   {
 486     CPPUNIT_FAIL(e.what());
 487   }
 488   catch( ... )
 489   {
 490     CPPUNIT_FAIL("Unknown exception");
 491   }
 492
 493   //#ifdef ENABLE_FORCED_FAILURES
 494   //Trying open file secondary.
 495   //CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver22->open(), MEDEXCEPTION);
 496   CPPUNIT_ASSERT_NO_THROW(aMedRdWrFieldDriver22->open());
 497   // (BUG) No exception in this case
 498   //#endif
 499
 500   //Trying read field from file if field name is empty
 501   CPPUNIT_ASSERT_THROW(aMedRdFieldDriver22->read(), MEDEXCEPTION);
 502
 503   //Test setFieldName() and getFieldName
 504   try
 505   {
 506     aMedRdWrFieldDriver22->setFieldName(fileldnotexist);
 507   }
 508   catch(MEDEXCEPTION &e)
 509   {
 510     CPPUNIT_FAIL(e.what());
 511   }
 512   catch( ... )
 513   {
 514     CPPUNIT_FAIL("Unknown exception");
 515   }
 516   CPPUNIT_ASSERT_EQUAL(fileldnotexist, aMedRdWrFieldDriver22->getFieldName());
 517
 518   //Trying read not existing field from file
 519   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver22->read(), MEDEXCEPTION);
 520
 521   //Test read() method
 522   aMedRdWrFieldDriver22->setFieldName(fieldnameDouble);
 523   try
 524   {
 525     aMedRdWrFieldDriver22->read();
 526   }
 527   catch(MEDEXCEPTION &e)
 528   {
 529     CPPUNIT_FAIL(e.what());
 530   }
 531   catch( ... )
 532   {
 533     CPPUNIT_FAIL("Unknown exception");
 534   }
 535
 536   //Trying write field in the file with empty name
 537   aField_2->setName(emptyfilename);
 538   aMedRdWrFieldDriver22->setFieldName(emptyfilename);
 539   CPPUNIT_ASSERT_THROW(aMedRdWrFieldDriver22->write(), MEDEXCEPTION);
 540
 541   //Test write() method
 542   aField_2->setName(fieldnameDouble_cpy);
 543   aMedRdWrFieldDriver22->setFieldName(fieldnameDouble_cpy);
 544   try
 545   {
 546     aMedRdWrFieldDriver22->write();
 547   }
 548   catch(MEDEXCEPTION &e)
 549   {
 550     CPPUNIT_FAIL(e.what());
 551   }
 552   catch( ... )
 553   {
 554     CPPUNIT_FAIL("Unknown exception");
 555   }
 556
 557   //Test close() method
 558   try
 559   {
 560     aMedRdWrFieldDriver22->close();
 561   }
 562   catch(MEDEXCEPTION &e)
 563   {
 564     CPPUNIT_FAIL(e.what());
 565   }
 566   catch( ... )
 567   {
 568     CPPUNIT_FAIL("Unknown exception");
 569   }
 570
 571   //Default constructor
 572   MED_FIELD_RDWR_DRIVER<double> aMedRdWrFieldDriver22Cpy_1;
 573
 574   //Test (void operator =) defined in GENDRIVER class
 575   aMedRdWrFieldDriver22Cpy_1 = *aMedRdWrFieldDriver22;
 576
 577   //Test (bool operator ==) defined in GENDRIVER class
 578   CPPUNIT_ASSERT(aMedRdWrFieldDriver22Cpy_1.GENDRIVER::operator==(*aMedRdWrFieldDriver22));
 579
 580   //Test copy constructor
 581   MED_FIELD_RDWR_DRIVER<double> aMedRdWrFieldDriver22Cpy_2 (*aMedRdWrFieldDriver22);
 582   CPPUNIT_ASSERT_EQUAL(aMedRdWrFieldDriver22Cpy_2, *aMedRdWrFieldDriver22);
 583
 584   //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 585   ostringstream rwostr1, rwostr2;
 586   rwostr1 << aMedRdWrFieldDriver22Cpy_1;
 587   rwostr2 << aMedRdWrFieldDriver22Cpy_2;
 588   CPPUNIT_ASSERT(rwostr1.str() != "");
 589   CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 590
 591   ///////////////////////////////////////////////////////////////////////////////////
 592   // Test for the issue 0021211. Check that a support of partial field
 593   // (group or family) is restored at reading
 594   {
 595     string filenameRDWR = makeTmpFile("filenameRDWR.med");
 596     aRemover.Register(filenameRDWR);
 597
 598     MESH* mesh = new MESH(MED_DRIVER, filenameWithOutFileds, "Mesh 1");
 599     mesh->setName("UniqueMeshName");
 600     //mesh->setMeshDimension(3); need to make mdump work on 2D mesh in 3D space
 601
 602     FAMILY* family = const_cast<FAMILY*>( mesh->getFamily( MED_EDGE, 1 ));
 603     family->setName( healName( family->getName() ));
 604
 605     // mesh is 2D, make a field on the 1st FAMILY of segments
 606     FIELD<double>* field = new FIELD<double>( family, /*NumberOfComponents=*/1);
 607     field->setName( "FieldOnFamily");
 608     field->setComponentsNames(&fileldnotexist);
 609     field->setComponentsDescriptions(&fileldnotexist);
 610     field->setMEDComponentsUnits(&fileldnotexist);
 611     double* vals = const_cast<double*>( field->getValue() );
 612     const int nbVals = family->getNumberOfElements( MED_ALL_ELEMENTS );
 613     for ( int i = 0; i < nbVals; ++i ) vals[i] = i;
 614
 615     // store the mesh and the field in a file
 616     int drv = mesh->addDriver( MED_DRIVER, filenameRDWR, mesh->getName() );
 617     CPPUNIT_ASSERT_NO_THROW( mesh->write(drv) );
 618     drv = field->addDriver( MED_DRIVER, filenameRDWR, field->getName() );
 619     CPPUNIT_ASSERT_NO_THROW( field->write(drv) );
 620
 621     // Check 1) read the field back and check it's support
 622     string familyName = family->getName();
 623     const SUPPORT* supOnAll = mesh->getSupportOnAll( family->getEntity() );
 624     FIELD<double>* field2 =
 625       new FIELD<double>( supOnAll, MED_DRIVER, filenameRDWR, field->getName());
 626     const SUPPORT* support2 = field2->getSupport();
 627     CPPUNIT_ASSERT( support2 == family );
 628     CPPUNIT_ASSERT_EQUAL( familyName, support2->getName() ); // name must not change
 629
 630     // Check 2) if a support with name corresponding to a profile is not found,
 631     // the new SUPPORT must not have name "SupportOnAll_MED_entity"
 632     ((FAMILY*)family)->setName("setName");
 633     FIELD<double>* field3 =
 634       new FIELD<double>( supOnAll, MED_DRIVER, filenameRDWR, field->getName());
 635     const SUPPORT* support3 = field3->getSupport();
 636     CPPUNIT_ASSERT( support3 != family );
 637     CPPUNIT_ASSERT( support3->getName() != supOnAll->getName());
 638
 639     // delete
 640     field->removeReference();
 641     field2->removeReference();
 642     field3->removeReference();
 643     mesh->removeReference();
 644   }
 645   // End Test for the issue 0021211
 646   ///////////////////////////////////////////////////////////////////////////////////
 647
 648   //Delete all objects
 649   aField->removeReference();
 650   aField_1->removeReference();
 651   aField_2->removeReference();
 652
 653   delete aInvalidMedRdFieldDriver22_1;
 654   delete aInvalidMedRdFieldDriver22_2;
 655   delete aInvalidMedRdFieldDriver22_3;
 656   delete aMedRdFieldDriver22;
 657
 658   delete aInvalidMedWrFieldDriver22_1;
 659   delete aInvalidMedWrFieldDriver22_2;
 660   delete aInvalidMedWrFieldDriver22_3;
 661   delete aInvalidMedWrFieldDriver22_4;
 662   delete aMedWrFieldDriver22;
 663
 664   delete aInvalidMedRdWrFieldDriver22_1;
 665   delete aInvalidMedRdWrFieldDriver22_2;
 666   delete aInvalidMedRdWrFieldDriver22_3;
 667   delete aInvalidMedRdWrFieldDriver22_4;
 668   delete aInvalidMedRdWrFieldDriver22_5;
 669   delete aMedRdWrFieldDriver22;
 670 }