src/MEDMEMCppTest/MEDMEMTest_PorflowMeshDriver.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_PorflowMeshDriver.hxx>
  26 #include <MEDMEM_Mesh.hxx>
  27
  28 // use this define to enable lines, execution of which leads to Segmentation Fault
  29 //#define ENABLE_FAULTS
  30
  31 // use this define to enable CPPUNIT asserts and fails, showing bugs
  32 //#define ENABLE_FORCED_FAILURES
  33
  34 using namespace std;
  35 using namespace MEDMEM;
  36
  37 /*!
  38  *  Check methods (18), defined in MEDMEM_PorflowMeshDriver.hxx:
  39  *  class PORFLOW_MESH_DRIVER : public GENDRIVER {
  40  *   (+) PORFLOW_MESH_DRIVER();
  41  *   (+) PORFLOW_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN::med_mode_acces accessMode);
  42  *   (+) PORFLOW_MESH_DRIVER(const PORFLOW_MESH_DRIVER & driver);
  43  *   (+) virtual ~PORFLOW_MESH_DRIVER();
  44  *   (+) void open() throw (MEDEXCEPTION);
  45  *   (+) void close() throw (MEDEXCEPTION);
  46  *   (-) virtual void write(void) const = 0;
  47  *   (+) virtual void read (void) = 0;
  48  *   (+) void   setMeshName(const string & meshName);
  49  *   (+) string getMeshName() const;
  50  *  }
  51  *  class PORFLOW_MESH_RDONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER {
  52  *   (+) PORFLOW_MESH_RDONLY_DRIVER();
  53  *   (+) PORFLOW_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh);
  54  *   (+) PORFLOW_MESH_RDONLY_DRIVER(const PORFLOW_MESH_RDONLY_DRIVER & driver);
  55  *   (+) virtual ~PORFLOW_MESH_RDONLY_DRIVER();
  56  *   (+) void write(void) const throw (MEDEXCEPTION);
  57  *   (+) void read (void) throw (MEDEXCEPTION);
  58  *  }
  59  *  class PORFLOW_MESH_WRONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER {
  60  *   (+) PORFLOW_MESH_WRONLY_DRIVER();
  61  *   (+) PORFLOW_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh);
  62  *   (+) PORFLOW_MESH_WRONLY_DRIVER(const PORFLOW_MESH_WRONLY_DRIVER & driver);
  63  *   (+) virtual ~PORFLOW_MESH_WRONLY_DRIVER();
  64  *   (NOT IMPLEMENTED!!!) void write(void) const throw (MEDEXCEPTION);
  65  *   (+) void read (void) throw (MEDEXCEPTION);
  66  *  }
  67  *  class PORFLOW_MESH_RDWR_DRIVER : public PORFLOW_MESH_RDONLY_DRIVER, public PORFLOW_MESH_WRONLY_DRIVER {
  68  *   (+) PORFLOW_MESH_RDWR_DRIVER();
  69  *   (+) PORFLOW_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh);
  70  *   (+) PORFLOW_MESH_RDWR_DRIVER(const PORFLOW_MESH_RDWR_DRIVER & driver);
  71  *   (+) ~PORFLOW_MESH_RDWR_DRIVER();
  72  *   (CALLS PORFLOW_MESH_WRONLY_DRIVER::write()) void write(void) const throw (MEDEXCEPTION);
  73  *   (+) void read (void) throw (MEDEXCEPTION);
  74  *  }
  75  */
  76 void MEDMEMTest::testPorflowMeshDriver()
  77 {
  78   MESH *aMesh                      = new MESH();
  79   MESH *aMesh_1                    = new MESH();
  80
  81   string data_dir                  = getenv("MED_ROOT_DIR");
  82   string tmp_dir                   = getenv("TMP") ? getenv("TMP") : "/tmp";
  83
  84   string filename_rd               = data_dir + "/share/salome/resources/med/Case1.inp";
  85   string filename_wr               = tmp_dir  + "/myWr_Case1.inp";
  86   string meshname                  = "Case1";
  87   string newmeshname               = "new" + meshname;
  88   string fileNotExistsName_rd      = "notExists.inp";
  89   string fileNotExistsName_wr      = "/path_not_exists/file_not_exists.inp";
  90   string filename_rdwr             =  tmp_dir  + "/myRdWr_Case1.inp";
  91   string fcopy                     = "cp " + filename_rd  + " " + filename_rdwr;
  92   string fcopy1                    = "cp " + data_dir + "/share/salome/resources/med/Case1.xyz" + " " + tmp_dir + "/Case1.xyz";
  93   string fcopy2                    = "cp " + data_dir + "/share/salome/resources/med/Case1.cnc" + " " + tmp_dir + "/Case1.cnc";
  94
  95   //Copy files in the TMP dir for testing READ/WRITE case
  96   system(fcopy.data());
  97   system(fcopy1.data());
  98   system(fcopy2.data());
  99
 100   MEDMEMTest_TmpFilesRemover aRemover;
 101   aRemover.Register(filename_wr);
 102   aRemover.Register(filename_rdwr);
 103   aRemover.Register(tmp_dir + "/Case1.xyz");
 104   aRemover.Register(tmp_dir + "/Case1.cnc");
 105
 106   //-----------------------------Test READ ONLY part---------------------------------------//
 107   {
 108     {
 109       //Creation a incorrect Porflow read only driver
 110       PORFLOW_MESH_RDONLY_DRIVER *aInvalidPorflowRdDriver =
 111         new PORFLOW_MESH_RDONLY_DRIVER(fileNotExistsName_rd, aMesh);
 112
 113       //Trying open not existing file
 114       CPPUNIT_ASSERT_THROW(aInvalidPorflowRdDriver->open(), MEDEXCEPTION);
 115
 116       delete aInvalidPorflowRdDriver;
 117     }
 118
 119     //Creation a correct Porflow read only driver (normal constructor)
 120     PORFLOW_MESH_RDONLY_DRIVER *aPorflowRdDriver = new PORFLOW_MESH_RDONLY_DRIVER(filename_rd, aMesh);
 121
 122     //Check driver
 123     CPPUNIT_ASSERT(aPorflowRdDriver);
 124
 125     //Trying read mesh from file, if file is not open
 126     CPPUNIT_ASSERT_THROW(aPorflowRdDriver->read(), MEDEXCEPTION);
 127
 128     //Test open() method
 129     // commented by skl - must be exception since thid file is
 130     // opened yet and such case is tested below
 131     //CPPUNIT_ASSERT_NO_THROW(aPorflowRdDriver->open());
 132
 133     //#ifdef ENABLE_FORCED_FAILURES
 134     //Trying open file secondary
 135     //CPPUNIT_ASSERT_THROW(aPorflowRdDriver->open(), MEDEXCEPTION);
 136     CPPUNIT_ASSERT_NO_THROW(aPorflowRdDriver->open());
 137     //This case  work, but it corrypt driver
 138     //#endif
 139
 140     //Test read() method
 141     CPPUNIT_ASSERT_NO_THROW(aPorflowRdDriver->read());
 142
 143     //Check Mesh
 144     CPPUNIT_ASSERT(aMesh);
 145
 146     //Trying fill not empty mesh
 147     CPPUNIT_ASSERT_THROW(aPorflowRdDriver->read(), MEDEXCEPTION);
 148
 149     //Test write() method for Porflow RDONLY Driver
 150     CPPUNIT_ASSERT_THROW(aPorflowRdDriver->write(), MEDEXCEPTION);
 151
 152     //Test setMeshName() and getMeshName()
 153     CPPUNIT_ASSERT_NO_THROW(aPorflowRdDriver->setMeshName(meshname));
 154     CPPUNIT_ASSERT_EQUAL(meshname, aPorflowRdDriver->getMeshName());
 155
 156     //Test close() method
 157     CPPUNIT_ASSERT_NO_THROW(aPorflowRdDriver->close());
 158
 159     //Default constructor
 160     PORFLOW_MESH_RDONLY_DRIVER aPorflowRdDriverCpy_1;
 161     // TO DO
 162
 163     //Test copy constructor
 164     PORFLOW_MESH_RDONLY_DRIVER aPorflowRdDriverCpy_2 (*aPorflowRdDriver);
 165
 166     //Test (bool operator ==) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 167     CPPUNIT_ASSERT(aPorflowRdDriverCpy_2.GENDRIVER::operator==(*aPorflowRdDriver));
 168
 169     //Test (friend ostream & operator <<) defined GENDRIVER class in MEDMEM_GenDriver.hxx
 170     ostringstream rostr1, rostr2;
 171     rostr1 << *aPorflowRdDriver;
 172     rostr2 << aPorflowRdDriverCpy_2;
 173     CPPUNIT_ASSERT(rostr1.str() != "");
 174     CPPUNIT_ASSERT_EQUAL(rostr1.str() , rostr2.str());
 175
 176     delete aPorflowRdDriver;
 177   }
 178
 179   //---------------------------Test WRITE ONLY part-------------------------------------//
 180   {
 181     {
 182       //Creation a incorrect Porflow write only driver
 183       PORFLOW_MESH_WRONLY_DRIVER *aInvalidPorflowWrDriver =
 184         new PORFLOW_MESH_WRONLY_DRIVER(fileNotExistsName_wr, aMesh);
 185
 186       //Test case: trying open non existing file
 187       CPPUNIT_ASSERT_THROW(aInvalidPorflowWrDriver->open(), MEDEXCEPTION);
 188
 189       delete aInvalidPorflowWrDriver;
 190     }
 191
 192     //Creation a correct write only driver
 193     PORFLOW_MESH_WRONLY_DRIVER *aPorflowWrDriver = new PORFLOW_MESH_WRONLY_DRIVER(filename_wr, aMesh);
 194
 195     //Check driver
 196     CPPUNIT_ASSERT(aPorflowWrDriver);
 197
 198     //Test case: trying write mesh to file, if file is not open
 199     CPPUNIT_ASSERT_THROW(aPorflowWrDriver->write(), MEDEXCEPTION);
 200
 201     //Test open() method
 202     //#ifndef ENABLE_FORCED_FAILURES
 203     FILE *tmpFile = fopen(filename_wr.data(), "w");
 204     fclose(tmpFile);
 205     //#endif
 206     CPPUNIT_ASSERT_NO_THROW(aPorflowWrDriver->open());
 207
 208     //Test case: trying open file secondary.
 209     CPPUNIT_ASSERT_THROW(aPorflowWrDriver->open(), MEDEXCEPTION);
 210
 211     //Test write() method
 212     //#ifdef ENABLE_FORCED_FAILURES
 213     //Write method is not implemented
 214     //CPPUNIT_ASSERT_NO_THROW(aPorflowWrDriver->write());
 215     CPPUNIT_ASSERT_THROW(aPorflowWrDriver->write(), MEDEXCEPTION);
 216     //#endif
 217
 218     //Test read() method for WRITE ONLY driver
 219     CPPUNIT_ASSERT_THROW(aPorflowWrDriver->read(), MEDEXCEPTION);
 220
 221     //Test setMeshName() and getMeshName()
 222     CPPUNIT_ASSERT_NO_THROW(aPorflowWrDriver->setMeshName(newmeshname));
 223     CPPUNIT_ASSERT_EQUAL(newmeshname, aPorflowWrDriver->getMeshName());
 224
 225     CPPUNIT_ASSERT_NO_THROW(aPorflowWrDriver->close());
 226
 227     //Default constructor
 228     PORFLOW_MESH_WRONLY_DRIVER aPorflowWrDriverCpy_1;
 229
 230     //Test copy constructor
 231     PORFLOW_MESH_WRONLY_DRIVER aPorflowWrDriverCpy_2 (*aPorflowWrDriver);
 232
 233     //Test (bool operator ==) defined in GENDRIVER class
 234     CPPUNIT_ASSERT(aPorflowWrDriverCpy_2.GENDRIVER::operator==(*aPorflowWrDriver));
 235
 236     //Test (friend ostream & operator <<) defined in GENDRIVER class
 237     ostringstream wostr1, wostr2;
 238     wostr1 << *aPorflowWrDriver;
 239     wostr2 << aPorflowWrDriverCpy_2;
 240     CPPUNIT_ASSERT(wostr1.str() != "");
 241     CPPUNIT_ASSERT(wostr1.str() == wostr2.str());
 242
 243     delete aPorflowWrDriver;
 244   }
 245
 246   //------------------------Test READ / WRITE part------------------------------------//
 247   {
 248     {
 249       //Creation a incorrect read/write driver
 250       PORFLOW_MESH_RDWR_DRIVER *aInvalidPorflowRdWrDriver =
 251         new PORFLOW_MESH_RDWR_DRIVER(fileNotExistsName_wr, aMesh_1);
 252
 253       //Test case: trying open non existing file
 254       CPPUNIT_ASSERT_THROW(aInvalidPorflowRdWrDriver->open(), MEDEXCEPTION);
 255
 256       delete aInvalidPorflowRdWrDriver;
 257     }
 258
 259     //Creation a correct read/write driver
 260     PORFLOW_MESH_RDWR_DRIVER *aPorflowRdWrDriver = new PORFLOW_MESH_RDWR_DRIVER(filename_rdwr, aMesh_1);
 261
 262     //Check driver
 263     CPPUNIT_ASSERT(aPorflowRdWrDriver);
 264
 265     //Test case: trying write mesh to file, if file is not open
 266     CPPUNIT_ASSERT_THROW(aPorflowRdWrDriver->write(), MEDEXCEPTION);
 267
 268     //Test case: trying read mesh from file, if file is not open
 269     CPPUNIT_ASSERT_THROW(aPorflowRdWrDriver->read(), MEDEXCEPTION);
 270
 271     //Test open() method
 272     CPPUNIT_ASSERT_NO_THROW(aPorflowRdWrDriver->open());
 273
 274     //Test case: trying open file secondary.
 275     //#ifdef ENABLE_FORCED_FAILURES
 276     // (BUG) This case work, but corrupt driver
 277     CPPUNIT_ASSERT_THROW(aPorflowRdWrDriver->open(), MEDEXCEPTION);
 278     //#endif
 279
 280     //Test read() method
 281     CPPUNIT_ASSERT_NO_THROW();
 282     CPPUNIT_ASSERT_NO_THROW(aPorflowRdWrDriver->read());
 283
 284     //Test write() method
 285     //aPorflowRdWrDriver->setMeshName(newmeshname);
 286     //aMesh->setName(newmeshname);
 287     //CPPUNIT_ASSERT_NO_THROW(aPorflowRdWrDriver->write());
 288     //Write method is not implemented
 289     //#ifdef ENABLE_FORCED_FAILURES
 290     //CPPUNIT_FAIL("PORFLOW_MESH_RDWR_DRIVER::write() method not implemented");
 291     //#endif
 292
 293     //Check Mesh
 294     CPPUNIT_ASSERT(aMesh);
 295
 296     CPPUNIT_ASSERT_NO_THROW(aPorflowRdWrDriver->close());
 297
 298     //Default constructor
 299     PORFLOW_MESH_RDWR_DRIVER aPorflowRdWrDriverCpy_1;
 300     // TO DO
 301
 302     //Test copy constructor
 303     PORFLOW_MESH_RDWR_DRIVER aPorflowRdWrDriverCpy_2 (*aPorflowRdWrDriver);
 304
 305     //Test (bool operator ==) defined in GENDRIVER class
 306     CPPUNIT_ASSERT(aPorflowRdWrDriverCpy_2.GENDRIVER::operator==(*aPorflowRdWrDriver));
 307
 308     //Test (friend ostream & operator <<) defined in GENDRIVER class
 309     ostringstream rwostr1, rwostr2;
 310     rwostr1 << *aPorflowRdWrDriver;
 311     rwostr2 << aPorflowRdWrDriverCpy_2;
 312     CPPUNIT_ASSERT(rwostr1.str() != "");
 313     CPPUNIT_ASSERT(rwostr1.str() == rwostr2.str());
 314
 315     delete aPorflowRdWrDriver;
 316   }
 317
 318   //Delete all objects
 319   delete aMesh;
 320   delete aMesh_1;
 321 }