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