src/MEDMEMCppTest/MEDMEMTest_DriverFactory.cxx

   1 // Copyright (C) 2007-2012  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/Message.h>
  22 #include <cppunit/TestAssert.h>
  23
  24 #include "MEDMEM_DriverFactory.hxx"
  25 #include "MEDMEM_Field.hxx"
  26 #include "MEDMEM_GenDriver.hxx"
  27 #include "MEDMEM_GibiMeshDriver.hxx"
  28 #include "MEDMEM_MedFieldDriver.hxx"
  29 #include "MEDMEM_MedMeshDriver.hxx"
  30 #include "MEDMEM_Mesh.hxx"
  31 #include "MEDMEM_PorflowMeshDriver.hxx"
  32 #include "MEDMEM_STRING.hxx"
  33 #include "MEDMEM_Support.hxx"
  34 #include "MEDMEM_VtkFieldDriver.hxx"
  35 #include "MEDMEM_VtkMedDriver.hxx"
  36 #include "MEDMEM_VtkMeshDriver.hxx"
  37
  38 #include <sstream>
  39 #include <cmath>
  40
  41 // use this define to enable lines, execution of which leads to Segmentation Fault
  42 //#define ENABLE_FAULTS
  43
  44 // use this define to enable CPPUNIT asserts and fails, showing bugs
  45 //#define ENABLE_FORCED_FAILURES
  46
  47 using namespace std;
  48 using namespace MEDMEM;
  49
  50 // #9: MEDMEM_DriverFactory.hxx  }  MEDMEMTest_DriverFactory.cxx
  51
  52 /*!
  53  *  Check methods (7), defined in MEDMEM_DriverFactory.hxx:
  54  *  namespace DRIVERFACTORY {
  55  *   (+)     driverTypes deduceDriverTypeFromFileName(const std::string & fileName);
  56  *
  57  *   (+)     GENDRIVER * buildDriverForMesh (driverTypes driverType, const std::string & fileName,
  58  *                                           MESH *mesh, const string & driverName,
  59  *                                           MED_EN::med_mode_acces access);
  60  *   (+)     template<class T, class INTERLACING_TAG>
  61  *           GENDRIVER * buildDriverForField(driverTypes driverType, const std::string & fileName,
  62  *                                           FIELD<T,INTERLACING_TAG> *fielde,
  63  *                                           MED_EN::med_mode_acces access);
  64  *
  65  *   (+)     GENDRIVER * buildMeshDriverFromFile (const string & fileName, MESH * ptrMesh,
  66  *                                                MED_EN::med_mode_acces access);
  67  *   (+)     template<class T, class INTERLACING_TAG>
  68  *           GENDRIVER * buildFieldDriverFromFile(const string & fileName,
  69  *                                                FIELD<T,INTERLACING_TAG> * ptrField,
  70  *                                                MED_EN::med_mode_acces access);
  71  *
  72  *   (+)     GENDRIVER * buildConcreteMedDriverForMesh(const std::string & fileName, MESH *mesh,
  73  *                                                     const string & driverName,
  74  *                                                     MED_EN::med_mode_acces access,
  75  *                                                     MED_EN::medFileVersion version);
  76  *   (+)     template<class T, class INTERLACING_TAG>
  77  *           GENDRIVER * buildConcreteMedDriverForField(const std::string & fileName,
  78  *                                                      FIELD<T,INTERLACING_TAG> *fielde,
  79  *                                                      MED_EN::med_mode_acces access,
  80  *                                                      MED_EN::medFileVersion version);
  81  *  }
  82  */
  83 void MEDMEMTest::testDriverFactory()
  84 {
  85   ///////////////////////////////////////////////////////////////////////
  86   // Test 1: getMedFileVersionForWriting & setMedFileVersionForWriting //
  87   ///////////////////////////////////////////////////////////////////////
  88
  89   // Obsolete, removed
  90
  91   //////////////////////////////////////////////////////////////////////////
  92   // Test 1b: getVtkBinaryFormatForWriting & setVtkBinaryFormatForWriting //
  93   //////////////////////////////////////////////////////////////////////////
  94
  95   // save current format
  96   bool wasBinary = DRIVERFACTORY::getVtkBinaryFormatForWriting();
  97
  98   // check changing format
  99   DRIVERFACTORY::setVtkBinaryFormatForWriting( !wasBinary );
 100   CPPUNIT_ASSERT(DRIVERFACTORY::getVtkBinaryFormatForWriting() == !wasBinary);
 101
 102   // restore default version preference
 103   DRIVERFACTORY::setVtkBinaryFormatForWriting(wasBinary);
 104
 105   //////////////////////////////////////////
 106   // Test 2: deduceDriverTypeFromFileName //
 107   //////////////////////////////////////////
 108   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("test.med")   == MED_DRIVER);
 109   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.sauve") == GIBI_DRIVER);
 110   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.sauv")  == GIBI_DRIVER);
 111   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.cnc")   == PORFLOW_DRIVER);
 112   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.inp")   == PORFLOW_DRIVER);
 113   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.xyz")   == PORFLOW_DRIVER);
 114   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.vtk")   == VTK_DRIVER);
 115   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t_st_med")   == NO_DRIVER);
 116   CPPUNIT_ASSERT(DRIVERFACTORY::deduceDriverTypeFromFileName("t.st.med1")  == NO_DRIVER);
 117
 118   ////////////////////////////////////////////////////////
 119   // Test building drivers for different types of files //
 120   ////////////////////////////////////////////////////////
 121   GENDRIVER * aDriver = NULL;
 122
 123   ///////////////////////////////
 124   // Test 3: buildDriverForMed //
 125   ///////////////////////////////
 126
 127   // Obsolete, removed
 128
 129   ////////////////////////////////
 130   // Test 4: buildDriverForMesh //
 131   ////////////////////////////////
 132   MESH *mesh=new MESH;
 133
 134   // 4.1: MED_DRIVER
 135
 136   // rdonly
 137   aDriver = DRIVERFACTORY::buildDriverForMesh
 138     (MED_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDONLY);
 139   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 140   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 141
 142
 143   MED_MESH_RDONLY_DRIVER * aMedRDriverForMesh = dynamic_cast<MED_MESH_RDONLY_DRIVER *> (aDriver);
 144   CPPUNIT_ASSERT(aMedRDriverForMesh);
 145   CPPUNIT_ASSERT(aMedRDriverForMesh->getMeshName() == "my driver name");
 146
 147
 148   delete aDriver; aDriver=0;
 149
 150   // wronly
 151   aDriver = DRIVERFACTORY::buildDriverForMesh
 152     (MED_DRIVER, "anyfile", mesh, "my driver name", MED_EN::WRONLY);
 153   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 154   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 155
 156   MED_MESH_WRONLY_DRIVER * aMedWDriverForMesh = dynamic_cast<MED_MESH_WRONLY_DRIVER *> (aDriver);
 157   CPPUNIT_ASSERT(aMedWDriverForMesh);
 158   CPPUNIT_ASSERT(aMedWDriverForMesh->getMeshName() == "my driver name");
 159
 160   delete aDriver; aDriver=0;
 161
 162   // rdwr
 163   aDriver = DRIVERFACTORY::buildDriverForMesh
 164     (MED_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDWR);
 165   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 166   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 167
 168   MED_MESH_RDWR_DRIVER * aMedRWDriverForMesh = dynamic_cast<MED_MESH_RDWR_DRIVER *> (aDriver);
 169   CPPUNIT_ASSERT(aMedRWDriverForMesh);
 170   CPPUNIT_ASSERT(aMedRWDriverForMesh->getMeshName() == "my driver name");
 171
 172   delete aDriver; aDriver=0;
 173
 174   // 4.2: GIBI_DRIVER
 175
 176   // rdonly
 177   aDriver = DRIVERFACTORY::buildDriverForMesh
 178     (GIBI_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDONLY);
 179   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 180   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 181
 182   GIBI_MESH_RDONLY_DRIVER * aGibiDriverForMesh = dynamic_cast<GIBI_MESH_RDONLY_DRIVER *> (aDriver);
 183   CPPUNIT_ASSERT(aGibiDriverForMesh);
 184
 185   delete aDriver; aDriver=0;
 186
 187   // wronly
 188   aDriver = DRIVERFACTORY::buildDriverForMesh
 189     (GIBI_DRIVER, "anyfile", mesh, "my driver name", MED_EN::WRONLY);
 190   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 191   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 192
 193   GIBI_MESH_WRONLY_DRIVER * aGibiWRDriverForMesh = dynamic_cast<GIBI_MESH_WRONLY_DRIVER*>(aDriver);
 194   CPPUNIT_ASSERT(aGibiWRDriverForMesh);
 195   delete aDriver; aDriver=0;
 196
 197   // rdwr
 198   aDriver = DRIVERFACTORY::buildDriverForMesh
 199     (GIBI_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDWR);
 200   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 201   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 202
 203   GIBI_MESH_RDWR_DRIVER * aGibiRWDriverForMesh = dynamic_cast<GIBI_MESH_RDWR_DRIVER*>(aDriver);
 204   CPPUNIT_ASSERT(aGibiRWDriverForMesh);
 205   delete aDriver; aDriver=0;
 206
 207   // 4.3: PORFLOW_DRIVER
 208
 209   // rdonly
 210   aDriver = DRIVERFACTORY::buildDriverForMesh
 211     (PORFLOW_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDONLY);
 212   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 213   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 214
 215   PORFLOW_MESH_RDONLY_DRIVER * aPorflowDriverForMesh = dynamic_cast<PORFLOW_MESH_RDONLY_DRIVER *> (aDriver);
 216   CPPUNIT_ASSERT(aPorflowDriverForMesh);
 217
 218   delete aDriver; aDriver=0;
 219
 220   // wronly
 221   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForMesh(PORFLOW_DRIVER, "anyfile", mesh,
 222                                                          "my driver name", MED_EN::WRONLY),
 223                        MED_EXCEPTION);
 224   // rdwr
 225   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForMesh(PORFLOW_DRIVER, "anyfile", mesh,
 226                                                          "my driver name", MED_EN::RDWR),
 227                        MED_EXCEPTION);
 228
 229   // 4.4: VTK_DRIVER
 230
 231   // rdonly
 232   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForMesh(VTK_DRIVER, "anyfile", mesh,
 233                                                          "my driver name", MED_EN::RDONLY),
 234                        MED_EXCEPTION);
 235
 236   // wronly
 237   aDriver = DRIVERFACTORY::buildDriverForMesh
 238     (VTK_DRIVER, "anyfile", mesh, "my driver name", MED_EN::WRONLY);
 239   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 240   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 241
 242   VTK_MESH_DRIVER * aVtkDriverForMesh = dynamic_cast<VTK_MESH_DRIVER *> (aDriver);
 243   CPPUNIT_ASSERT(aVtkDriverForMesh);
 244
 245   delete aDriver; aDriver=0;
 246
 247   // rdwr
 248   aDriver = DRIVERFACTORY::buildDriverForMesh
 249     (VTK_DRIVER, "anyfile", mesh, "my driver name", MED_EN::RDWR);
 250   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 251   // next string is commented by skl since VTK driver is
 252   // created without mode
 253   //CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 254
 255   aVtkDriverForMesh = dynamic_cast<VTK_MESH_DRIVER *> (aDriver);
 256   CPPUNIT_ASSERT(aVtkDriverForMesh);
 257
 258   delete aDriver; aDriver=0;
 259
 260   // 4.5: ASCII_DRIVER
 261   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForMesh(ASCII_DRIVER, "anyfile", mesh,
 262                                                          "my driver name", MED_EN::RDONLY),
 263                        MED_EXCEPTION);
 264
 265   // 4.6: NO_DRIVER
 266   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForMesh(NO_DRIVER, "anyfile", mesh,
 267                                                          "my driver name", MED_EN::RDONLY),
 268                        MED_EXCEPTION);
 269
 270   /////////////////////////////////
 271   // Test 5: buildDriverForField //
 272   /////////////////////////////////
 273   FIELD<double> *field=new FIELD<double>();
 274
 275   // 5.1: MED_DRIVER
 276
 277   // rdonly
 278   aDriver = DRIVERFACTORY::buildDriverForField(MED_DRIVER, "anyfile", field, MED_EN::RDONLY);
 279   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 280   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 281
 282   MED_FIELD_RDONLY_DRIVER<double> * aMedRDriverForField =
 283     dynamic_cast<MED_FIELD_RDONLY_DRIVER<double> *> (aDriver);
 284   CPPUNIT_ASSERT(aMedRDriverForField);
 285
 286   delete aDriver; aDriver=0;
 287
 288   // wronly
 289   aDriver = DRIVERFACTORY::buildDriverForField(MED_DRIVER, "anyfile", field, MED_EN::WRONLY);
 290   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 291   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 292
 293   MED_FIELD_WRONLY_DRIVER<double> * aMedWDriverForField =
 294     dynamic_cast<MED_FIELD_WRONLY_DRIVER<double> *> (aDriver);
 295   CPPUNIT_ASSERT(aMedWDriverForField);
 296
 297   delete aDriver; aDriver=0;
 298
 299   // rdwr
 300   aDriver = DRIVERFACTORY::buildDriverForField(MED_DRIVER, "anyfile", field, MED_EN::RDWR);
 301   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 302   CPPUNIT_ASSERT_EQUAL(MED_EN::RDWR,aDriver->getAccessMode());
 303
 304   MED_FIELD_RDWR_DRIVER<double> * aMedRWDriverForField =
 305     dynamic_cast<MED_FIELD_RDWR_DRIVER<double> *> (aDriver);
 306   CPPUNIT_ASSERT(aMedRWDriverForField);
 307
 308   delete aDriver; aDriver=0;
 309
 310   // 5.2: GIBI_DRIVER
 311
 312   // rdonly
 313   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(GIBI_DRIVER, "anyfile", field, MED_EN::RDONLY),
 314                        MED_EXCEPTION);
 315   // wronly
 316   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(GIBI_DRIVER, "anyfile", field, MED_EN::WRONLY),
 317                        MED_EXCEPTION);
 318   // rdwr
 319   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(GIBI_DRIVER, "anyfile", field, MED_EN::RDWR),
 320                        MED_EXCEPTION);
 321
 322   // 5.3: PORFLOW_DRIVER
 323
 324   // rdonly
 325   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(PORFLOW_DRIVER, "anyfile",
 326                                                           field, MED_EN::RDONLY),
 327                        MED_EXCEPTION);
 328   // wronly
 329   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(PORFLOW_DRIVER, "anyfile",
 330                                                           field, MED_EN::WRONLY),
 331                        MED_EXCEPTION);
 332   // rdwr
 333   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(PORFLOW_DRIVER, "anyfile",
 334                                                           field, MED_EN::RDWR),
 335                        MED_EXCEPTION);
 336
 337   // 5.4: VTK_DRIVER
 338
 339   // rdonly
 340   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(VTK_DRIVER, "anyfile", field, MED_EN::RDONLY),
 341                        MED_EXCEPTION);
 342
 343   // wronly
 344   aDriver = DRIVERFACTORY::buildDriverForField(VTK_DRIVER, "anyfile", field, MED_EN::WRONLY);
 345   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 346   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 347
 348   VTK_FIELD_DRIVER<double> * aVtkDriverForField = dynamic_cast<VTK_FIELD_DRIVER<double> *> (aDriver);
 349   CPPUNIT_ASSERT(aVtkDriverForField);
 350
 351   delete aDriver; aDriver=0;
 352
 353   // rdwr
 354   aDriver = DRIVERFACTORY::buildDriverForField(VTK_DRIVER, "anyfile", field, MED_EN::RDWR);
 355   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 356   // next string is commented by skl since VTK driver is
 357   // created without mode
 358   //CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 359
 360   aVtkDriverForField = dynamic_cast<VTK_FIELD_DRIVER<double> *> (aDriver);
 361   CPPUNIT_ASSERT(aVtkDriverForField);
 362
 363   delete aDriver; aDriver=0;
 364
 365   // 5.5: ASCII_DRIVER
 366
 367   // rdonly
 368   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(ASCII_DRIVER, "anyfile", field, MED_EN::RDONLY),
 369                        MED_EXCEPTION);
 370   // rdwr
 371   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(ASCII_DRIVER, "anyfile", field, MED_EN::RDWR),
 372                        MED_EXCEPTION);
 373
 374   // wronly
 375   // it throws on empty field
 376   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(ASCII_DRIVER, "anyfile", field, MED_EN::WRONLY),
 377                        MED_EXCEPTION);
 378
 379   // now try with valid field
 380   string filename  = getResourceFile("pointe.med");
 381   string meshname  = "maa1";
 382   string fieldname = "fieldcelldoublescalar";
 383   FIELD<double> * aField1 = new FIELD<double>(MED_DRIVER, filename, fieldname);
 384   const SUPPORT * aSupport = aField1->getSupport();
 385   MESH * aMesh = new MESH (MED_DRIVER, filename, aSupport->getMeshName());
 386   aSupport->setMesh(aMesh);
 387
 388   aDriver = DRIVERFACTORY::buildDriverForField(ASCII_DRIVER, "anyfile", aField1, MED_EN::WRONLY);
 389   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 390   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 391
 392   // it works!
 393   //aDriver->open();
 394   //aDriver->write();
 395   //aDriver->close();
 396
 397   ASCII_FIELD_DRIVER<double> * anAsciiDriverForField =
 398     dynamic_cast<ASCII_FIELD_DRIVER<double> *> (aDriver);
 399   CPPUNIT_ASSERT(anAsciiDriverForField);
 400
 401   delete aDriver; aDriver=0;
 402
 403   aField1->removeReference();
 404   aMesh->removeReference();
 405
 406   // 5.6: NO_DRIVER
 407   CPPUNIT_ASSERT_THROW(DRIVERFACTORY::buildDriverForField(NO_DRIVER, "anyfile", field, MED_EN::RDONLY),
 408                        MED_EXCEPTION);
 409
 410   ////////////////////////////////////
 411   // Test 6: buildMedDriverFromFile //
 412   ////////////////////////////////////
 413   string aFileName1 = getResourceFile("pointe.med");
 414   string aFileName2 = getResourceFile("polyedres.med");
 415   medFileVersion version1, version2;
 416
 417   try {
 418     version1 = getMedFileVersion(aFileName1);
 419   } catch (MEDEXCEPTION & ex) {
 420     version1 = MED_EN::V22;
 421   }
 422
 423   try {
 424     version2 = getMedFileVersion(aFileName2);
 425   } catch (MEDEXCEPTION & ex) {
 426     version2 = MED_EN::V22;
 427   }
 428
 429   // 6.1. Med file V2.1
 430   string aFileName21 = aFileName1;
 431   if (version1 == MED_EN::V21 || version2 == MED_EN::V21) {
 432     if (version1 == MED_EN::V22)
 433       aFileName21 = aFileName2;
 434
 435   }
 436
 437 //   // 6.2. Med file V2.2
 438   string aFileName22 = aFileName2;
 439   if (version2 == MED_EN::V22 || version1 == MED_EN::V22) {
 440     if (version2 == MED_EN::V21)
 441       aFileName22 = aFileName1;
 442
 443   }
 444
 445   /////////////////////////////////////
 446   // Test 7: buildMeshDriverFromFile //
 447   /////////////////////////////////////
 448
 449   // 7.1. Med file V2.1
 450   if (version1 == MED_EN::V21 || version2 == MED_EN::V21) {
 451     // Obsolete, removed
 452   }
 453
 454   // 7.2. Med file V2.2
 455   if (version2 == MED_EN::V22 || version1 == MED_EN::V22) {
 456     // rdonly
 457     aDriver = DRIVERFACTORY::buildMeshDriverFromFile(aFileName22, mesh, MED_EN::RDONLY);
 458     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 459     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 460
 461     MED_MESH_RDONLY_DRIVER * aMeshRDriverForMed22 = dynamic_cast<MED_MESH_RDONLY_DRIVER *> (aDriver);
 462     CPPUNIT_ASSERT(aMeshRDriverForMed22);
 463
 464     delete aDriver; aDriver=0;
 465
 466     // wronly
 467     aDriver = DRIVERFACTORY::buildMeshDriverFromFile(aFileName22, mesh, MED_EN::WRONLY);
 468     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 469     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 470
 471     MED_MESH_WRONLY_DRIVER * aMeshWDriverForMed22 = dynamic_cast<MED_MESH_WRONLY_DRIVER *> (aDriver);
 472     CPPUNIT_ASSERT(aMeshWDriverForMed22);
 473
 474     delete aDriver; aDriver=0;
 475
 476     // rdwr
 477     aDriver = DRIVERFACTORY::buildMeshDriverFromFile(aFileName22, mesh, MED_EN::RDWR);
 478     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 479     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 480
 481     MED_MESH_RDWR_DRIVER * aMeshRWDriverForMed22 = dynamic_cast<MED_MESH_RDWR_DRIVER *> (aDriver);
 482     CPPUNIT_ASSERT(aMeshRWDriverForMed22);
 483
 484     delete aDriver; aDriver=0;
 485   }
 486
 487   //////////////////////////////////////
 488   // Test 8: buildFieldDriverFromFile //
 489   //////////////////////////////////////
 490
 491   // 8.1. Med file V2.1
 492   if (version1 == MED_EN::V21 || version2 == MED_EN::V21) {
 493     // rdonly
 494     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName21, field, MED_EN::RDONLY);
 495     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName21);
 496     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 497
 498     delete aDriver; aDriver=0;
 499
 500     // wronly
 501     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName21, field, MED_EN::WRONLY);
 502     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName21);
 503     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 504
 505     delete aDriver; aDriver=0;
 506
 507     // rdwr
 508     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName21, field, MED_EN::RDWR);
 509     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName21);
 510     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR); // see MEDMEM_define.hxx
 511
 512     delete aDriver; aDriver=0;
 513   }
 514
 515   // 8.2. Med file V2.2
 516   if (version2 == MED_EN::V22 || version1 == MED_EN::V22) {
 517     // rdonly
 518     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName22, field, MED_EN::RDONLY);
 519     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 520     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 521
 522     MED_FIELD_RDONLY_DRIVER<double> * aFieldRDriverForMed22 =
 523       dynamic_cast<MED_FIELD_RDONLY_DRIVER<double> *> (aDriver);
 524     CPPUNIT_ASSERT(aFieldRDriverForMed22);
 525
 526     delete aDriver; aDriver=0;
 527
 528     // wronly
 529     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName22, field, MED_EN::WRONLY);
 530     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 531     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 532
 533     MED_FIELD_WRONLY_DRIVER<double> * aFieldWDriverForMed22 =
 534       dynamic_cast<MED_FIELD_WRONLY_DRIVER<double> *> (aDriver);
 535     CPPUNIT_ASSERT(aFieldWDriverForMed22);
 536
 537     delete aDriver; aDriver=0;
 538
 539     // rdwr
 540     aDriver = DRIVERFACTORY::buildFieldDriverFromFile(aFileName22, field, MED_EN::RDWR);
 541     CPPUNIT_ASSERT(aDriver->getFileName() == aFileName22);
 542     CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR); // see MEDMEM_define.hxx
 543
 544     MED_FIELD_RDWR_DRIVER<double> * aFieldRWDriverForMed22 =
 545       dynamic_cast<MED_FIELD_RDWR_DRIVER<double> *> (aDriver);
 546     CPPUNIT_ASSERT(aFieldRWDriverForMed22);
 547
 548     delete aDriver; aDriver=0;
 549   }
 550
 551   ///////////////////////////////////////////
 552   // Test 9: buildConcreteMedDriverForMesh //
 553   ///////////////////////////////////////////
 554
 555   // 9.1. V2.1
 556
 557   // rdonly
 558   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 559                                                                               MED_EN::RDONLY, MED_EN::V21),
 560                        MED_EXCEPTION);
 561   delete aDriver; aDriver=0;
 562
 563   // wronly
 564   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 565                                                                               MED_EN::WRONLY, MED_EN::V21),
 566                        MED_EXCEPTION);
 567
 568   delete aDriver; aDriver=0;
 569
 570   // rdwr
 571   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 572                                                                               MED_EN::RDWR, MED_EN::V21),
 573                        MED_EXCEPTION);
 574
 575   delete aDriver; aDriver=0;
 576
 577   // 9.2. V2.2
 578
 579   // rdonly
 580   aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 581                                                          MED_EN::RDONLY, MED_EN::V22);
 582   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 583   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 584
 585   MED_MESH_RDONLY_DRIVER * aMeshRDriverForMed22 = dynamic_cast<MED_MESH_RDONLY_DRIVER *> (aDriver);
 586   CPPUNIT_ASSERT(aMeshRDriverForMed22);
 587   CPPUNIT_ASSERT(aMeshRDriverForMed22->getMeshName() == "my driver name");
 588
 589   delete aDriver; aDriver=0;
 590
 591   // wronly
 592   aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 593                                                          MED_EN::WRONLY, MED_EN::V22);
 594   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 595   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 596
 597   MED_MESH_WRONLY_DRIVER * aMeshWDriverForMed22 = dynamic_cast<MED_MESH_WRONLY_DRIVER *> (aDriver);
 598   CPPUNIT_ASSERT(aMeshWDriverForMed22);
 599   CPPUNIT_ASSERT(aMeshWDriverForMed22->getMeshName() == "my driver name");
 600
 601   delete aDriver; aDriver=0;
 602
 603   // rdwr
 604   aDriver = DRIVERFACTORY::buildConcreteMedDriverForMesh("anyfile", mesh, "my driver name",
 605                                                          MED_EN::RDWR, MED_EN::V22);
 606   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 607   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR);
 608
 609   MED_MESH_RDWR_DRIVER * aMeshRWDriverForMed22 = dynamic_cast<MED_MESH_RDWR_DRIVER *> (aDriver);
 610   CPPUNIT_ASSERT(aMeshRWDriverForMed22);
 611   CPPUNIT_ASSERT(aMeshRWDriverForMed22->getMeshName() == "my driver name");
 612   mesh->removeReference();
 613   delete aDriver; aDriver=0;
 614
 615   /////////////////////////////////////////////
 616   // Test 10: buildConcreteMedDriverForField //
 617   /////////////////////////////////////////////
 618
 619   // 10.1. V2.1
 620
 621   // rdonly
 622   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::RDONLY, MED_EN::V21),
 623                        MED_EXCEPTION);
 624   delete aDriver; aDriver=0;
 625
 626   // wronly
 627   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::WRONLY, MED_EN::V21),
 628                        MED_EXCEPTION);
 629   delete aDriver; aDriver=0;
 630
 631   // rdwr
 632   CPPUNIT_ASSERT_THROW(aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::RDWR, MED_EN::V21), MED_EXCEPTION);
 633   delete aDriver; aDriver=0;
 634
 635   // 10.2. V2.2
 636
 637   // rdonly
 638   aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::RDONLY, MED_EN::V22);
 639   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 640   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDONLY);
 641
 642   MED_FIELD_RDONLY_DRIVER<double> * aFieldRDriverForMed22 =
 643     dynamic_cast<MED_FIELD_RDONLY_DRIVER<double> *> (aDriver);
 644   CPPUNIT_ASSERT(aFieldRDriverForMed22);
 645
 646   delete aDriver; aDriver=0;
 647
 648   // wronly
 649   aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::WRONLY, MED_EN::V22);
 650   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 651   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::WRONLY);
 652
 653   MED_FIELD_WRONLY_DRIVER<double> * aFieldWDriverForMed22 =
 654     dynamic_cast<MED_FIELD_WRONLY_DRIVER<double> *> (aDriver);
 655   CPPUNIT_ASSERT(aFieldWDriverForMed22);
 656
 657   delete aDriver; aDriver=0;
 658
 659   // rdwr
 660   aDriver = DRIVERFACTORY::buildConcreteMedDriverForField("anyfile", field, MED_EN::RDWR, MED_EN::V22);
 661   field->removeReference();
 662   CPPUNIT_ASSERT(aDriver->getFileName() == "anyfile");
 663   CPPUNIT_ASSERT(aDriver->getAccessMode() == MED_EN::RDWR); // see MEDMEM_define.hxx
 664
 665   MED_FIELD_RDWR_DRIVER<double> * aFieldRWDriverForMed22 =
 666     dynamic_cast<MED_FIELD_RDWR_DRIVER<double> *> (aDriver);
 667   CPPUNIT_ASSERT(aFieldRWDriverForMed22);
 668
 669   delete aDriver; aDriver=0;
 670 }