src/MEDMEMCppTest/MEDMEMTest.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_Exception.hxx"
  24 #include "MEDMEM_Group.hxx"
  25 #include "MEDMEM_IndexCheckingPolicy.hxx"
  26 #include "MEDMEM_MedFieldDriver.hxx"
  27 #include "MEDMEM_Mesh.hxx"
  28 #include "MEDMEM_Meshing.hxx"
  29 #include "MEDMEM_STRING.hxx"
  30 #include "MEDMEM_Remapper.hxx"
  31
  32 #include <sstream>
  33 #include <cmath>
  34 #include <stdexcept>
  35
  36 #ifdef WIN32
  37 #include <windows.h>
  38 #endif
  39
  40 using namespace std;
  41
  42 // ============================================================================
  43 /*!
  44  *  Set up the environment
  45  */
  46 // ============================================================================
  47 void MEDMEMTest::setUp()
  48 {
  49 }
  50
  51 // ============================================================================
  52 /*!
  53  *  - delete
  54  */
  55 // ============================================================================
  56 void MEDMEMTest::tearDown()
  57 {
  58 }
  59
  60 /*
  61 // #1: MEDMEM_Array.hxx                \
  62 // #2: MEDMEM_ArrayConvert.hxx          }  MEDMEMTest_Array.cxx
  63 // #3: MEDMEM_ArrayInterface.hxx (-)   /
  64 // #4: MEDMEM_AsciiFieldDriver.hxx      }  MEDMEMTest_AsciiFieldDriver.cxx
  65 // #5: MEDMEM_CellModel.hxx             }  MEDMEMTest.cxx (-)
  66 // #7: MEDMEM_Connectivity.hxx          }  MEDMEMTest_Connectivity.cxx
  67 // #8: MEDMEM_Coordinate.hxx            }  MEDMEMTest_Coordinate.cxx
  68 // #9: MEDMEM_DriverFactory.hxx         }  MEDMEMTest_DriverFactory.cxx
  69 // #10: MEDMEM_DriversDef.hxx           }  MEDMEMTest.cxx (-)
  70 // #11: MEDMEM_DriverTools.hxx          }  MEDMEMTest.cxx (-)
  71 // #12: MEDMEM_Exception.hxx            }  MEDMEMTest_Exception.cxx
  72 // #13: MEDMEM_Family.hxx               }  MEDMEMTest.cxx
  73 // #14: MEDMEM_Field.hxx                \
  74 // #15: MEDMEM_FieldConvert.hxx         /  MEDMEMTest_Field.cxx
  75 // #16: MEDMEM_FieldForward.hxx         }  no methods to test
  76 // #17: MEDMEM_Formulae.hxx             }  MEDMEMTest_Formulae.cxx
  77 // #18: MEDMEM_GaussLocalization.hxx    }  MEDMEMTest_GaussLocalization.cxx
  78 // #19: MEDMEM_GenDriver.hxx  }  abstract class; implemented methods are tested during its successors testing
  79 // #20: MEDMEM_GibiMeshDriver.hxx       }  MEDMEMTest_GibiMeshDriver.cxx
  80 // #21: MEDMEM_Grid.cxx                 }  MEDMEMTest_Grid.cxx
  81 // #22: MEDMEM_Group.cxx                }  MEDMEMTest_Group.cxx
  82 // #23: MEDMEM_IndexCheckingPolicy.cxx  }  MEDMEMTest.cxx
  83 // #24: MEDMEM_Init.cxx                 }  MEDMEMTest.cxx
  84 // #25: MEDMEM_InterlacingPolicy.hxx    }  MEDMEMTest.cxx (-)
  85 // #26: MEDMEM_InterlacingTraits.hxx    }  MEDMEMTest.cxx (-)
  86 // #28: MEDMEM_MedFieldDriver.hxx       }  MEDMEMTest_MedFieldDriver.cxx
  87 // #34: MEDMEM_MEDMEMchampLire.hxx      }  MEDMEMTest.cxx (-)
  88 // #35: MEDMEM_MEDMEMgaussEcr.hxx       }  MEDMEMTest.cxx (-)
  89 // #36: MEDMEM_MEDMEMprofilEcr.hxx      }  MEDMEMTest.cxx (-)
  90 // #37: MEDMEM_MedMeshDriver.hxx        }  MEDMEMTest_MedMeshDriver.cxx
  91 // #40: MEDMEM_MedVersion.hxx           }  MEDMEMTest_MedVersion.cxx
  92 // #41: MEDMEM_Mesh.hxx                 \
  93 // #42: MEDMEM_Meshing.hxx              /  MEDMEMTest_MeshAndMeshing.cxx
  94 // #43: MEDMEM_ModulusArray.hxx         }  MEDMEMTest_ModulusArray.cxx
  95 // #44: MEDMEM_nArray.hxx               }  MEDMEMTest_nArray.cxx
  96 // #45: MEDMEM_PointerOf.hxx            }  MEDMEMTest_PointerOf.cxx
  97 // #47: MEDMEM_PorflowMeshDriver.hxx    }  MEDMEMTest_PorflowMeshDriver.cxx
  98 // #48: MEDMEM_RCBase.hxx               }  MEDMEMTest.cxx (-)
  99 // #49: MEDMEM_SetInterlacingType.hxx   }  MEDMEMTest.cxx (-)
 100 // #50: MEDMEM_SkyLineArray.hxx         }  MEDMEMTest_SkyLineArray.cxx
 101 // #51: MEDMEM_STRING.hxx               }  MEDMEMTest.cxx
 102 // #52: MEDMEM_Support.hxx              }  MEDMEMTest_Support.cxx
 103 // #53: MEDMEM_Tags.hxx                 }  MEDMEMTest.cxx (-)
 104 // #54: MEDMEM_TopLevel.hxx             }  MEDMEMTest_TopLevel.cxx
 105 // #55: MEDMEM_TypeMeshDriver.hxx       }  MEDMEMTest.cxx
 106 // #56: MEDMEM_Unit.hxx                 }  MEDMEMTest_Unit.cxx
 107 // #57: MEDMEM_VtkFieldDriver.hxx       }  MEDMEMTest_VtkFieldDriver.cxx
 108 // #58: MEDMEM_VtkMedDriver.hxx         }  MEDMEMTest_VtkMedDriver.cxx
 109 // #59: MEDMEM_VtkMeshDriver.hxx        }  MEDMEMTest_VtkMeshDriver.cxx
 110 // #60: MEDMEM_medimport_src.hxx        }  MEDMEMTest.cxx (-)
 111 */
 112
 113 /*!
 114  *  Check methods (4), defined in MEDMEM_IndexCheckingPolicy.hxx:
 115  *  class IndexCheckPolicy {
 116  *   (+)     void checkMoreThanZero(const std::string & classname, int index) const;
 117  *   (+)     void checkLessOrEqualThan(const std::string & classname, int max, int index) const;
 118  *   (+)     void checkInInclusiveRange(const std::string & classname, int min, int max, int index) const;
 119  *   (+)     void checkEquality(const std::string & classname, int a, int b) const;
 120  *  }
 121  *  class NoIndexCheckPolicy {
 122  *   (+)     void checkMoreThanZero(const string &classname, int index) const;
 123  *   (+)     void checkLessOrEqualThan(const std::string & classname, int max, int index) const;
 124  *   (+)     void checkInInclusiveRange(const std::string & classname, int min, int max, int index) const;
 125  *   (+)     void checkEquality(const std::string & classname, int a, int b) const;
 126  *  }
 127  */
 128 void MEDMEMTest::testIndexCheckingPolicy()
 129 {
 130   MEDMEM::IndexCheckPolicy do_check;
 131   MEDMEM::NoIndexCheckPolicy no_check;
 132
 133   int min = 3;
 134   int max = 10;
 135
 136   string aClassName ("MEDMEMTest::testIndexCheckingPolicy");
 137
 138   // IndexCheckPolicy: throw, if index does not satisfy criteria
 139   CPPUNIT_ASSERT_THROW(do_check.checkMoreThanZero(aClassName, -1), MEDMEM::MEDEXCEPTION);
 140   CPPUNIT_ASSERT_THROW(do_check.checkLessOrEqualThan(aClassName, max, 13), MEDMEM::MEDEXCEPTION);
 141   CPPUNIT_ASSERT_THROW(do_check.checkInInclusiveRange(aClassName, min, max, 1), MEDMEM::MEDEXCEPTION);
 142   // checkEquality() check that values are not equal
 143   CPPUNIT_ASSERT_THROW(do_check.checkEquality(aClassName, 21, 21), MEDMEM::MEDEXCEPTION);
 144
 145   // NoIndexCheckPolicy: do not throw, if index does not satisfy criteria
 146   CPPUNIT_ASSERT_NO_THROW(no_check.checkMoreThanZero(aClassName, -1));
 147   CPPUNIT_ASSERT_NO_THROW(no_check.checkLessOrEqualThan(aClassName, max, 13));
 148   CPPUNIT_ASSERT_NO_THROW(no_check.checkInInclusiveRange(aClassName, min, max, 1));
 149   CPPUNIT_ASSERT_NO_THROW(no_check.checkEquality(aClassName, 21, 21));
 150
 151   // IndexCheckPolicy: do not throw, if index satisfy criteria
 152   CPPUNIT_ASSERT_NO_THROW(do_check.checkMoreThanZero(aClassName, 5));
 153   CPPUNIT_ASSERT_NO_THROW(do_check.checkLessOrEqualThan(aClassName, max, 7));
 154   CPPUNIT_ASSERT_NO_THROW(do_check.checkInInclusiveRange(aClassName, min, max, 6));
 155   CPPUNIT_ASSERT_NO_THROW(do_check.checkEquality(aClassName, 21, 28));
 156
 157   // NoIndexCheckPolicy: do not throw, if index satisfy criteria
 158   CPPUNIT_ASSERT_NO_THROW(no_check.checkMoreThanZero(aClassName, 5));
 159   CPPUNIT_ASSERT_NO_THROW(no_check.checkLessOrEqualThan(aClassName, max, 7));
 160   CPPUNIT_ASSERT_NO_THROW(no_check.checkInInclusiveRange(aClassName, min, max, 6));
 161   CPPUNIT_ASSERT_NO_THROW(no_check.checkEquality(aClassName, 21, 28));
 162 }
 163
 164 /*!
 165  *  Check initialization, done in MEDMEM_Init.cxx:
 166  *  (-) MEDMEM::INIT init;
 167  */
 168 void MEDMEMTest::testInit()
 169 {
 170   // We cannot check here effect of initialization, done in MEDMEM_Init.cxx,
 171   // because environment variable, set there, is visible only in libmedmem.la
 172   // and its child processes (if any).
 173
 174   // Check effect of MEDMEM_Init.cxx
 175   //char* traceKind = getenv("SALOME_trace");
 176   //CPPUNIT_ASSERT(traceKind);
 177 }
 178
 179 /*!
 180  *  Check methods (not in spec), defined in MEDMEM_InterlacingPolicy.hxx:
 181  */
 182 //void MEDMEMTest::testInterlacingPolicy()
 183 //{
 184 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 185 //}
 186
 187 /*!
 188  *  Check methods (not in spec), defined in MEDMEM_InterlacingTraits.hxx:
 189  */
 190 //void MEDMEMTest::testInterlacingTraits()
 191 //{
 192 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 193 //}
 194
 195 /*!
 196  *  Check methods (not in spec), defined in MEDMEM_MedFieldDriver.hxx:
 197  */
 198 //void MEDMEMTest::testMedFieldDriver()
 199 //{
 200 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 201 //}
 202
 203 /*!
 204  *  Check methods (not in spec), defined in MEDMEM_MEDMEMchampLire.hxx:
 205  */
 206 //void MEDMEMTest::testMEDMEMchampLire()
 207 //{
 208 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 209 //}
 210
 211 /*!
 212  *  Check methods (not in spec), defined in MEDMEM_MEDMEMgaussEcr.hxx:
 213  */
 214 //void MEDMEMTest::testMEDMEMgaussEcr()
 215 //{
 216 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 217 //}
 218
 219 /*!
 220  *  Check methods (not in spec), defined in MEDMEM_MEDMEMprofilEcr.hxx:
 221  */
 222 //void MEDMEMTest::testMEDMEMprofilEcr()
 223 //{
 224 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 225 //}
 226
 227 /*!
 228  *  Check methods (not in spec), defined in MEDMEM_MedMeshDriver.hxx:
 229  */
 230 //void MEDMEMTest::testMedMeshDriver()
 231 //{
 232 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 233 //}
 234
 235 /*!
 236  *  Check methods (not in spec), defined in MEDMEM_RCBase.hxx:
 237  *  class RCBASE {
 238  *   (reference counter presently disconnected in C++) virtual void addReference() const = 0;
 239  *   (reference counter presently disconnected in C++) virtual void removeReference() const = 0;
 240  *  }
 241  */
 242 //void MEDMEMTest::testRCBase()
 243 //{
 244 //  // nothing to test
 245 //}
 246
 247 /*!
 248  *  Check methods (not in spec), defined in MEDMEM_SetInterlacingType.hxx:
 249  */
 250 //void MEDMEMTest::testSetInterlacingType()
 251 //{
 252 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 253 //}
 254
 255 /*!
 256  *  Check methods (2), defined in MEDMEM_STRING.hxx:
 257  *  class STRING : public string {
 258  *   (+)     STRING()
 259  *   (+)     ~STRING()
 260  *   (+)     operator const char * () const
 261  *   (+)     template <class T> STRING(const T &valeur)
 262  *   (+)     template <class T> STRING & operator<<(const T &valeur)
 263  *  }
 264  */
 265 void MEDMEMTest::testSTRING()
 266 {
 267   {
 268     // empty constructor
 269     MEDMEM::STRING medstr;
 270     CPPUNIT_ASSERT(strcmp(medstr.c_str(), "") == 0);
 271
 272     // template <class T> STRING & operator<<(const T &valeur) with T == char*
 273     //medstr << <char*>"filling 1";
 274     medstr << "filling " << 1 << " !!!";
 275     CPPUNIT_ASSERT(strcmp(medstr.c_str(), "filling 1 !!!") == 0);
 276
 277     // operator const char * ()
 278     CPPUNIT_ASSERT(strcmp((const char *)medstr, "filling 1 !!!") == 0);
 279     CPPUNIT_ASSERT(strcmp(              medstr, "filling 1 !!!") == 0);
 280   }
 281
 282   MEDMEM::MESH * aMesh1 = MEDMEMTest_createTestMesh();
 283   ostringstream ostr;
 284   ostr << *aMesh1;
 285
 286   {
 287     // template <class T> STRING & operator<<(const T &valeur) with T == MEDMEM::MESH
 288     MEDMEM::STRING medstr;
 289     //medstr << <char*>"filling 1";
 290     medstr << *aMesh1;
 291     CPPUNIT_ASSERT(strcmp(medstr, ostr.str().c_str()) == 0);
 292   }
 293
 294   {
 295     // Constructor STRING(const T &valeur) with T == char*
 296     //MEDMEM::STRING medstr<char*>("filling 2");
 297     MEDMEM::STRING medstr ("filling 2");
 298     CPPUNIT_ASSERT(strcmp(medstr.c_str(), "filling 2") == 0);
 299     CPPUNIT_ASSERT(strcmp(medstr, "filling 2") == 0);
 300   }
 301
 302   {
 303     // Constructor STRING(const T &valeur) with T == MEDMEM::MESH
 304     MEDMEM::STRING medstr (*aMesh1);
 305     CPPUNIT_ASSERT(strcmp(medstr, ostr.str().c_str()) == 0);
 306   }
 307   if(aMesh1)
 308     aMesh1->removeReference();
 309 }
 310
 311 /*!
 312  *  Check methods (not in spec), defined in MEDMEM_Tags.hxx:
 313  */
 314 //void MEDMEMTest::testTags()
 315 //{
 316 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 317 //}
 318
 319 /*!
 320  *  Check methods (15), defined in MEDMEM_TypeMeshDriver.hxx:
 321  *  class TYPE_MESH_DRIVER : public GENDRIVER {
 322  *   (-) TYPE_MESH_DRIVER();
 323  *   (-) TYPE_MESH_DRIVER(const string & fileName, MESH * ptrMesh, med_mode_acces accessMode);
 324  *   (-) TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver);
 325  *   (-) virtual ~TYPE_MESH_DRIVER();
 326  *   (-) void open() throw (MEDEXCEPTION);
 327  *   (-) void close() throw (MEDEXCEPTION);
 328  *   (-) virtual void write(void) const = 0;
 329  *   (-) virtual void read (void) = 0;
 330  *   (-) void   setMeshName(const string & meshName);
 331  *   (-) string getMeshName() const;
 332  *  }
 333  *  class TYPE_MESH_RDONLY_DRIVER : public virtual TYPE_MESH_DRIVER {
 334  *   (-) TYPE_MESH_RDONLY_DRIVER();
 335  *   (-) TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh);
 336  *   (-) TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver);
 337  *   (-) virtual ~TYPE_MESH_RDONLY_DRIVER();
 338  *   (-) void write(void) const throw (MEDEXCEPTION);
 339  *   (-) void read (void) throw (MEDEXCEPTION);
 340  *  }
 341  *  class TYPE_MESH_WRONLY_DRIVER : public virtual TYPE_MESH_DRIVER {
 342  *   (-) TYPE_MESH_WRONLY_DRIVER();
 343  *   (-) TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh);
 344  *   (-) TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver);
 345  *   (-) virtual ~TYPE_MESH_WRONLY_DRIVER();
 346  *   (-) void write(void) const throw (MEDEXCEPTION);
 347  *   (-) void read (void) throw (MEDEXCEPTION);
 348  *  }
 349  *  class TYPE_MESH_RDWR_DRIVER : public TYPE_MESH_RDONLY_DRIVER, public TYPE_MESH_WRONLY_DRIVER {
 350  *   (-) TYPE_MESH_RDWR_DRIVER();
 351  *   (-) TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh);
 352  *   (-) TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver);
 353  *   (-) ~TYPE_MESH_RDWR_DRIVER();
 354  *   (-) void write(void) const throw (MEDEXCEPTION);
 355  *   (-) void read (void) throw (MEDEXCEPTION);
 356  *  }
 357  */
 358 void MEDMEMTest::testTypeMeshDriver()
 359 {
 360   CPPUNIT_FAIL("TYPE_MESH_DRIVER: not implemented");
 361 }
 362
 363 /*!
 364  *  Check methods (not in spec), defined in MEDMEM_medimport_src.hxx:
 365  */
 366 //void MEDMEMTest::testmedimport_src()
 367 //{
 368 //  CPPUNIT_FAIL("Case Not Implemented (not in spec)");
 369 //}
 370
 371 //60
 372 //21 not in spec
 373
 374 //////////////////////////////////////
 375 // HELP METHODS, used in many tests //
 376 //////////////////////////////////////
 377
 378 /*!
 379  *  Create a mesh with certain filling
 380  *                 .n4
 381  *                 |
 382  *                 |
 383  *  n16,n12,n8.---------.n7,n11,n15
 384  *            |    |    |
 385  *            |    |    |
 386  *     n5.----|----.----|----.n3
 387  *            |    |    |
 388  *            |    |    |
 389  *  n17,n13,n9.---------.n10,n14,n18
 390  *                 |
 391  *                 |
 392  *                 .n6
 393  *
 394  *                 .n19 (0,0,5)
 395  *                 |
 396  *                 |
 397  *                 |
 398  *                 |
 399  *           n16.--|-.----.n15
 400  *             /   |/    /
 401  *            .    .    .
 402  *           /    /|   /
 403  *       n17.----.----.n18
 404  *                 |
 405  *                 |
 406  *           n12.--|-.----.n11
 407  *             /   |/    /
 408  *            .    .    .
 409  *           /    /|   /
 410  *       n13.----.----.n14
 411  *                 |
 412  *                 |
 413  *            n8.--|-.----.n7
 414  *             /   |/    /
 415  *            .    .    .
 416  *           /    /|   /
 417  *        n9.----.----.n10
 418  *                 |   .n4 (0,2,1)
 419  *                 |  /
 420  *                 | .
 421  *                 |/
 422  *     n5.----.----.----.----.n3 (2,0,1)
 423  *   (-2,0,1)     /n2 (0,0,1)
 424  *               . |
 425  *              /  |
 426  *             .n6 |
 427  *                 |
 428  *                 |
 429  *                 .n1 (0,0,0)
 430  */
 431 MEDMEM::MESH * MEDMEMTest_createTestMesh ()
 432 {
 433   // MESH DATA
 434   int SpaceDimension = 3;
 435
 436   // coordinates
 437   int NumberOfNodes = 19;
 438
 439   string Names[3] = { "X","Y","Z" };
 440   string Units[3] = { "cm","cm","cm" };
 441
 442   double Coordinates[57] = {
 443      0.0,  0.0, 0.0, // n1
 444      0.0,  0.0, 1.0, // n2
 445      2.0,  0.0, 1.0, // n3
 446      0.0,  2.0, 1.0, // n4
 447     -2.0,  0.0, 1.0, // n5
 448      0.0, -2.0, 1.0, // n6
 449      1.0,  1.0, 2.0, // n7
 450     -1.0,  1.0, 2.0, // n8
 451     -1.0, -1.0, 2.0, // n9
 452      1.0, -1.0, 2.0, // n10
 453      1.0,  1.0, 3.0, // n11
 454     -1.0,  1.0, 3.0, // n12
 455     -1.0, -1.0, 3.0, // n13
 456      1.0, -1.0, 3.0, // n14
 457      1.0,  1.0, 4.0, // n15
 458     -1.0,  1.0, 4.0, // n16
 459     -1.0, -1.0, 4.0, // n17
 460      1.0, -1.0, 4.0, // n18
 461      0.0,  0.0, 5.0  // n19
 462   };
 463
 464   // cells connectivities
 465   const int NumberOfCellTypes = 3;
 466   MED_EN::medGeometryElement CellTypes[NumberOfCellTypes] =
 467     {MED_EN::MED_TETRA4, MED_EN::MED_PYRA5, MED_EN::MED_HEXA8};
 468   const int NumberOfCells[NumberOfCellTypes] = {12, 2, 2};
 469
 470   int ConnectivityTetra[12 * 4] = {
 471     1,2,3,6,
 472     1,2,4,3,
 473     1,2,5,4,
 474     1,2,6,5,
 475     2,7,4,3,
 476     2,8,5,4,
 477     2,9,6,5,
 478     2,10,3,6,
 479     2,7,3,10,
 480     2,8,4,7,
 481     2,9,5,8,
 482     2,10,6,9
 483   };
 484
 485   int ConnectivityPyra[2 * 5] = {
 486     7,8,9,10,2,
 487     15,18,17,16,19
 488   };
 489
 490   int ConnectivityHexa[2 * 8] = {
 491     11,12,13,14,7,8,9,10,
 492     15,16,17,18,11,12,13,14
 493   };
 494
 495   // faces connectivities
 496   const int NumberOfFaceTypes = 2;
 497   MED_EN::medGeometryElement FaceTypes[NumberOfFaceTypes] = {MED_EN::MED_TRIA3, MED_EN::MED_QUAD4};
 498   const int NumberOfFaces[NumberOfFaceTypes] = {4, 4};
 499
 500   int ConnectivityTria[4 * 3] = {
 501     1,4,3,
 502     1,5,4,
 503     1,6,5,
 504     1,3,6
 505   };
 506
 507   int ConnectivityQua[4 * 4] = {
 508     7,8,9,10,
 509     11,12,13,14,
 510     11,7,8,12,
 511     12,8,9,13
 512   };
 513
 514
 515   // CREATE THE MESH
 516   MEDMEM::MESHING* myMeshing = new MEDMEM::MESHING;
 517
 518   myMeshing->setName("meshing");
 519
 520   myMeshing->setCoordinates(SpaceDimension, NumberOfNodes, Coordinates,
 521                            "CARTESIAN", MED_EN::MED_FULL_INTERLACE);
 522   myMeshing->setCoordinatesNames(Names);
 523   myMeshing->setCoordinatesUnits(Units);
 524
 525   // define connectivities
 526   myMeshing->setNumberOfTypes(NumberOfCellTypes, MED_EN::MED_CELL);
 527   myMeshing->setTypes(CellTypes, MED_EN::MED_CELL);
 528   myMeshing->setNumberOfElements(NumberOfCells, MED_EN::MED_CELL);
 529
 530   myMeshing->setConnectivity(MED_EN::MED_CELL, MED_EN::MED_TETRA4, ConnectivityTetra );
 531   myMeshing->setConnectivity(MED_EN::MED_CELL, MED_EN::MED_PYRA5 , ConnectivityPyra  );
 532   myMeshing->setConnectivity(MED_EN::MED_CELL, MED_EN::MED_HEXA8 , ConnectivityHexa  );
 533
 534   myMeshing->setNumberOfTypes(NumberOfFaceTypes, MED_EN::MED_FACE);
 535   myMeshing->setTypes(FaceTypes, MED_EN::MED_FACE);
 536   myMeshing->setNumberOfElements(NumberOfFaces, MED_EN::MED_FACE);
 537
 538   myMeshing->setConnectivity(MED_EN::MED_FACE, MED_EN::MED_TRIA3,ConnectivityTria);
 539   myMeshing->setConnectivity(MED_EN::MED_FACE, MED_EN::MED_QUAD4,ConnectivityQua);
 540
 541   // edges connectivities
 542   // not yet implemented : if set, results are unpredictable.
 543
 544   // groups of nodes
 545   {
 546     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 547     myGroup->setName("SomeNodes");
 548     myGroup->setMesh(myMeshing);
 549     myGroup->setEntity(MED_EN::MED_NODE);
 550     myGroup->setNumberOfGeometricType(1);
 551     MED_EN::medGeometryElement myTypes[1] = {MED_EN::MED_NONE};
 552     myGroup->setGeometricType(myTypes);
 553     const int myNumberOfElements[1] = {4};
 554     myGroup->setNumberOfElements(myNumberOfElements);
 555     const int index[1+1] = {1,5};
 556     const int value[4] = {1,4,5,7};
 557     myGroup->setNumber(index,value);
 558     myMeshing->addGroup(*myGroup);
 559     myGroup->removeReference();
 560   }
 561   {
 562     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 563     myGroup->setName("OtherNodes");
 564     myGroup->setMesh(myMeshing);
 565     myGroup->setEntity(MED_EN::MED_NODE);
 566     myGroup->setNumberOfGeometricType(1);
 567     MED_EN::medGeometryElement myTypes[1] = {MED_EN::MED_NONE};
 568     myGroup->setGeometricType(myTypes);
 569     const int myNumberOfElements[1] = {3};
 570     myGroup->setNumberOfElements(myNumberOfElements);
 571     const int index[1+1] = {1,4};
 572     const int value[3] = {2,3,6};
 573     myGroup->setNumber(index,value);
 574     myMeshing->addGroup(*myGroup);
 575     myGroup->removeReference();
 576   }
 577
 578   // groups of cells
 579   {
 580     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 581     myGroup->setName("SomeCells");
 582     myGroup->setMesh(myMeshing);
 583     myGroup->setEntity(MED_EN::MED_CELL);
 584     myGroup->setNumberOfGeometricType(3);
 585     MED_EN::medGeometryElement myTypes[3] = {MED_EN::MED_TETRA4,MED_EN::MED_PYRA5,MED_EN::MED_HEXA8};
 586     myGroup->setGeometricType(myTypes);
 587     const int myNumberOfElements[3] = {4,1,2};
 588     myGroup->setNumberOfElements(myNumberOfElements);
 589     const int index[3+1] = {1,5,6,8};
 590     const int value[4+1+2] = {2,7,8,12,  13,  15,16};
 591     myGroup->setNumber(index,value);
 592     myMeshing->addGroup(*myGroup);
 593     myGroup->removeReference();
 594   }
 595   {
 596     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 597     myGroup->setName("OtherCells");
 598     myGroup->setMesh(myMeshing);
 599     myGroup->setEntity(MED_EN::MED_CELL);
 600     myGroup->setNumberOfGeometricType(2);
 601     MED_EN::medGeometryElement myTypes[] = {MED_EN::MED_TETRA4,MED_EN::MED_PYRA5};
 602     myGroup->setGeometricType(myTypes);
 603     const int myNumberOfElements[] = {4,1};
 604     myGroup->setNumberOfElements(myNumberOfElements);
 605     const int index[2+1] = {1,5,6};
 606     const int value[4+1] = {3,4,5,9,  14};
 607     myGroup->setNumber(index,value);
 608     myMeshing->addGroup(*myGroup);
 609     myGroup->removeReference();
 610   }
 611
 612   // groups of faces
 613   {
 614     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 615     myGroup->setName("SomeFaces");
 616     myGroup->setMesh(myMeshing);
 617     myGroup->setEntity(MED_EN::MED_FACE);
 618     myGroup->setNumberOfGeometricType(2);
 619     MED_EN::medGeometryElement myTypes[2] = {MED_EN::MED_TRIA3,MED_EN::MED_QUAD4};
 620     myGroup->setGeometricType(myTypes);
 621     const int myNumberOfElements[2] = {2,3};
 622     myGroup->setNumberOfElements(myNumberOfElements);
 623     const int index[2+1] = {1,3,6};
 624     const int value[2+3] = {2,4,  5,6,8};
 625     myGroup->setNumber(index,value);
 626     myMeshing->addGroup(*myGroup);
 627     myGroup->removeReference();
 628   }
 629   {
 630     MEDMEM::GROUP *myGroup=new MEDMEM::GROUP;
 631     myGroup->setName("OtherFaces");
 632     myGroup->setMesh(myMeshing);
 633     myGroup->setEntity(MED_EN::MED_FACE);
 634     myGroup->setNumberOfGeometricType(1);
 635     MED_EN::medGeometryElement myTypes[1] = {MED_EN::MED_TRIA3};
 636     myGroup->setGeometricType(myTypes);
 637     const int myNumberOfElements[1] = {2};
 638     myGroup->setNumberOfElements(myNumberOfElements);
 639     const int index[1+1] = {1,3};
 640     const int value[2] = {1,3};
 641     myGroup->setNumber(index,value);
 642     myMeshing->addGroup(*myGroup);
 643     myGroup->removeReference();
 644   }
 645
 646   return myMeshing;
 647 }
 648
 649 /*!
 650  *  Tool to remove temporary files.
 651  *  Allows automatique removal of temporary files in case of test failure.
 652  */
 653 MEDMEMTest_TmpFilesRemover::~MEDMEMTest_TmpFilesRemover()
 654 {
 655   set<string>::iterator it = myTmpFiles.begin();
 656   for (; it != myTmpFiles.end(); it++) {
 657 #ifdef WIN32
 658     //if (GetFileAttributes((*it).data()) & FILE_ATTRIBUTE_NORMAL)
 659     if (GetFileAttributes((*it).data()) != INVALID_FILE_ATTRIBUTES)
 660 #else
 661     if (access((*it).data(), F_OK) == 0)
 662 #endif
 663       remove((*it).data());
 664   }
 665   myTmpFiles.clear();
 666   //cout << "~MEDMEMTest_TmpFilesRemover()" << endl;
 667 }
 668
 669 bool MEDMEMTest_TmpFilesRemover::Register(const string theTmpFile)
 670 {
 671   return (myTmpFiles.insert(theTmpFile)).second;
 672 }