MEDMEMTest Class Reference

#include <MEDMEMTest.hxx>

Inheritance diagram for MEDMEMTest:

Public Member Functions
void	setUp ()
void	tearDown ()
void	testArray ()
void	testArrayConvert ()
void	testAsciiFieldDriver ()
void	testConnectivity ()
void	testCoordinate ()
void	testDriverFactory ()
void	testException ()
void	testFamily ()
void	testField ()
void	testFieldConvert ()
void	testFormulae ()
void	testGaussLocalization ()
void	testGibiMeshDriver ()
void	testGrid ()
void	testGroup ()
void	testIndexCheckingPolicy ()
void	testInit ()
void	testMedFieldDriver21 ()
void	testMedFieldDriver22 ()
void	testReadFieldOnNodesAndCells ()
	0020582: [CEA 368] MEDMEM don't work with a same field on NODES and CELLS Before fixing the issue there was the error: RuntimeError: MED Exception in .../MED_SRC/src/MEDMEM/MEDMEM_MedFieldDriver22.hxx [503] : MED_FIELD_DRIVER<T>.createFieldSupportPart1(...) Field \|field on NODEs and CELLs\| with (ndt,or) = (-1,-1) must not be defined on different entity types
void	testMed ()
void	testMedMedDriver21 ()
void	testMedMedDriver22 ()
void	testMedMeshDriver21 ()
void	testMedMeshDriver22 ()
void	testMedVersion ()
void	testMeshAndMeshing ()
void	testModulusArray ()
void	testnArray ()
void	testPartialDescendingConnectivity ()
void	testPointerOf ()
void	testPolyhedronArray ()
void	testPorflowMeshDriver ()
void	testSkyLineArray ()
void	testSTRING ()
void	testSupport ()
void	testTopLevel ()
void	testTypeMeshDriver ()
void	testUnit ()
void	testVtkFieldDriver ()
void	testVtkMedDriver ()
void	testVtkMeshDriver ()
void	testExtractor ()
void	testDesactivateFacesComputation ()
void	testGetVolumeAbs ()
void	test_RemapperP0P0 ()
void	test_RemapperP1P1 ()
void	test_RemapperP1P0 ()
void	test_RemapperP0P1 ()
void	test_remapper4 ()
void	test_remapper5 ()
void	test_remapper6 ()
void	test_remapper7 ()
void	test_remapper3DTo1D ()
void	absField (MEDMEM::FIELD< double > &)
double	sumAll (const std::vector< std::map< int, double > > &matrix)
Private Member Functions
	CPPUNIT_TEST_SUITE (MEDMEMTest)
	CPPUNIT_TEST (testArray)
	CPPUNIT_TEST (testArrayConvert)
	CPPUNIT_TEST (testAsciiFieldDriver)
	CPPUNIT_TEST (testConnectivity)
	CPPUNIT_TEST (testCoordinate)
	CPPUNIT_TEST (testDriverFactory)
	CPPUNIT_TEST (testFamily)
	CPPUNIT_TEST (testField)
	CPPUNIT_TEST (testFieldConvert)
	CPPUNIT_TEST (testFormulae)
	CPPUNIT_TEST (testGaussLocalization)
	CPPUNIT_TEST (testGibiMeshDriver)
	CPPUNIT_TEST (testGroup)
	CPPUNIT_TEST (testIndexCheckingPolicy)
	CPPUNIT_TEST (testInit)
	CPPUNIT_TEST (testMedFieldDriver21)
	CPPUNIT_TEST (testMedFieldDriver22)
	CPPUNIT_TEST (testReadFieldOnNodesAndCells)
	CPPUNIT_TEST (testMed)
	CPPUNIT_TEST (testMedMedDriver21)
	CPPUNIT_TEST (testMedMedDriver22)
	CPPUNIT_TEST (testMedMeshDriver21)
	CPPUNIT_TEST (testMedMeshDriver22)
	CPPUNIT_TEST (testMedVersion)
	CPPUNIT_TEST (testMeshAndMeshing)
	CPPUNIT_TEST (testModulusArray)
	CPPUNIT_TEST (testnArray)
	CPPUNIT_TEST (testPartialDescendingConnectivity)
	CPPUNIT_TEST (testPointerOf)
	CPPUNIT_TEST (testPolyhedronArray)
	CPPUNIT_TEST (testPorflowMeshDriver)
	CPPUNIT_TEST (testSkyLineArray)
	CPPUNIT_TEST (testSTRING)
	CPPUNIT_TEST (testSupport)
	CPPUNIT_TEST (testUnit)
	CPPUNIT_TEST (testVtkFieldDriver)
	CPPUNIT_TEST (testVtkMedDriver)
	CPPUNIT_TEST (testVtkMeshDriver)
	CPPUNIT_TEST (testExtractor)
	CPPUNIT_TEST (testDesactivateFacesComputation)
	CPPUNIT_TEST (testGetVolumeAbs)
	CPPUNIT_TEST (test_remapper4)
	CPPUNIT_TEST (test_remapper5)
	CPPUNIT_TEST (test_remapper6)
	CPPUNIT_TEST (test_remapper7)
	CPPUNIT_TEST (test_remapper3DTo1D)
	CPPUNIT_TEST (test_RemapperP0P0)
	CPPUNIT_TEST (test_RemapperP1P1)
	CPPUNIT_TEST (test_RemapperP1P0)
	CPPUNIT_TEST (test_RemapperP0P1)
	CPPUNIT_TEST_SUITE_END ()

Member Function Documentation

MEDMEMTest.CPPUNIT_TEST_SUITE ( MEDMEMTest ) [private]

MEDMEMTest.CPPUNIT_TEST ( testArray ) [private]

MEDMEMTest.CPPUNIT_TEST ( testArrayConvert ) [private]

MEDMEMTest.CPPUNIT_TEST ( testAsciiFieldDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testConnectivity ) [private]

MEDMEMTest.CPPUNIT_TEST ( testCoordinate ) [private]

MEDMEMTest.CPPUNIT_TEST ( testDriverFactory ) [private]

MEDMEMTest.CPPUNIT_TEST ( testFamily ) [private]

MEDMEMTest.CPPUNIT_TEST ( testField ) [private]

MEDMEMTest.CPPUNIT_TEST ( testFieldConvert ) [private]

MEDMEMTest.CPPUNIT_TEST ( testFormulae ) [private]

MEDMEMTest.CPPUNIT_TEST ( testGaussLocalization ) [private]

MEDMEMTest.CPPUNIT_TEST ( testGibiMeshDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testGroup ) [private]

MEDMEMTest.CPPUNIT_TEST ( testIndexCheckingPolicy ) [private]

MEDMEMTest.CPPUNIT_TEST ( testInit ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedFieldDriver21 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedFieldDriver22 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testReadFieldOnNodesAndCells ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMed ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedMedDriver21 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedMedDriver22 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedMeshDriver21 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedMeshDriver22 ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMedVersion ) [private]

MEDMEMTest.CPPUNIT_TEST ( testMeshAndMeshing ) [private]

MEDMEMTest.CPPUNIT_TEST ( testModulusArray ) [private]

MEDMEMTest.CPPUNIT_TEST ( testnArray ) [private]

MEDMEMTest.CPPUNIT_TEST ( testPartialDescendingConnectivity ) [private]

MEDMEMTest.CPPUNIT_TEST ( testPointerOf ) [private]

MEDMEMTest.CPPUNIT_TEST ( testPolyhedronArray ) [private]

MEDMEMTest.CPPUNIT_TEST ( testPorflowMeshDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testSkyLineArray ) [private]

MEDMEMTest.CPPUNIT_TEST ( testSTRING ) [private]

MEDMEMTest.CPPUNIT_TEST ( testSupport ) [private]

MEDMEMTest.CPPUNIT_TEST ( testUnit ) [private]

MEDMEMTest.CPPUNIT_TEST ( testVtkFieldDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testVtkMedDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testVtkMeshDriver ) [private]

MEDMEMTest.CPPUNIT_TEST ( testExtractor ) [private]

MEDMEMTest.CPPUNIT_TEST ( testDesactivateFacesComputation ) [private]

MEDMEMTest.CPPUNIT_TEST ( testGetVolumeAbs ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_remapper4 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_remapper5 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_remapper6 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_remapper7 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_remapper3DTo1D ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_RemapperP0P0 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_RemapperP1P1 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_RemapperP1P0 ) [private]

MEDMEMTest.CPPUNIT_TEST ( test_RemapperP0P1 ) [private]

MEDMEMTest.CPPUNIT_TEST_SUITE_END ( ) [private]

void MEDMEMTest::setUp ( )

Set up the environment

void MEDMEMTest::tearDown ( )

delete

void MEDMEMTest::testArray ( )

Check methods (20), defined in MEDMEM_Array.hxx: template <class t>=""> class MEDARRAY { (+) inline MEDARRAY(); (+) inline ~MEDARRAY(); (+) MEDARRAY (const int ld_values, const int length_values, const MED_EN.medModeSwitch mode=MED_ENMED_FULL_INTERLACE); (+) MEDARRAY (T* values, const int ld_values, const int length_values, const MED_EN.medModeSwitch mode=MED_ENMED_FULL_INTERLACE, bool shallowCopy=false, bool ownershipOfValues=false); (+) MEDARRAY (MEDARRAY const &m); (+) MEDARRAY (MEDARRAY const &m, bool copyOther); (+) MEDARRAY & operator = (const MEDARRAY & m); (+) MEDARRAY & shallowCopy(const MEDARRAY & m); (+) inline int getLeadingValue() const; (+) inline int getLengthValue() const; (+) const T * get (const MED_EN.medModeSwitch mode); (+) const T * getRow (const int i); (+) const T * getColumn (const int j); (+) const T getIJ (const int i, const int j) const; (+) inline MED_EN.medModeSwitch getMode() const; (+) void set (const MED_EN.medModeSwitch mode,const T* value); (+) void setI (const int i, const T* value); (+) void setJ (const int j, const T* value); (+) void setIJ (const int i, const int j, const T value); (+) void calculateOther(); (+) bool isOtherCalculated() const {return (const T*)_valuesOther != NULL;} (+) void clearOtherMode(); }

Use code of MEDMEM/tests/testUArray.cxx, MEDMEM/test_MEDMEM_Array.cxx

*shallowCopy=*/true, /*ownershipOfValues=*/true);

void MEDMEMTest::testArrayConvert ( )

Check methods (4), defined in MEDMEM_ArrayConvert.hxx:

(+) Gauss NoInterlace->FullInterlace: template <class T, class CHECKING_POLICY > MEDMEM_Array<T, FullInterlaceGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, NoInterlaceGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) Gauss FullInterlace->NoInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, NoInterlaceGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, FullInterlaceGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) NoGauss FullInterlace->NoInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, NoInterlaceNoGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, FullInterlaceNoGaussPolicy, CHECKING_POLICY > &array, T* values=0)

(+) NoGauss NoInterlace->FullInterlace: template <class T, class CHECKING_POLICY> MEDMEM_Array<T, FullInterlaceNoGaussPolicy, CHECKING_POLICY> * ArrayConvert(const MEDMEM_Array< T, NoInterlaceNoGaussPolicy, CHECKING_POLICY > &array, T* values=0)

Use code of MEDMEM/test_MEDMEM_nArray.cxx

References MEDMEM.ArrayConvert(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJ(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getIJK(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.getPtr(), MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJ(), and MEDMEM.MEDMEM_Array< ARRAY_ELEMENT_TYPE, INTERLACING_POLICY, CHECKING_POLICY >.setIJK().

void MEDMEMTest::testAsciiFieldDriver ( )

Check methods (8), defined in MEDMEM_AsciiFieldDriver.hxx:

(+) template<int N,unsigned int CODE> void fill(double *a, const double *b) (+) template<int N> bool compare(const double* a, const double* b) (+) template<> void fill<-1,0x3>(double *a, const double *b); (+) template<> bool compare<-1>(const double *a, const double *b);

template <class T, int SPACEDIMENSION, unsigned int SORTSTRATEGY> class SDForSorting { (+) SDForSorting(const double *coords, const T* comp, int nbComponents); (+) SDForSorting(const SDForSorting& other); (+) ~SDForSorting(); (+) bool operator< (const SDForSorting<T,SPACEDIMENSION,SORTSTRATEGY>& other) const; (+) void writeLine(ofstream& file) const; }

template <class t>=""> class ASCII_FIELD_DRIVER : public GENDRIVER {

//MUST BE PRIVATE as there is no possibility to set _ptrField after this constructor usage (-) template <class interlacing_tag>=""> ASCII_FIELD_DRIVER();

(+) template <class interlacing_tag>=""> ASCII_FIELD_DRIVER(const string & fileName, FIELD<T,INTERLACING_TAG> * ptrField, MED_EN.med_sort_direc direction=MED_ENASCENDING, const char *priority=""); (+) ASCII_FIELD_DRIVER(const ASCII_FIELD_DRIVER<T>& other); (+) void open() throw (MEDEXCEPTION); (+) void close(); (+) void read (void) throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) GENDRIVER* copy() const; }

References MED_EN.ASCENDING, MEDMEM.ASCII_FIELD_DRIVER< T >.close(), MEDMEM.compare<-1 >(), MEDMEM.ASCII_FIELD_DRIVER< T >.copy(), test_NonCoincidentDEC.filename, MEDMEM.GENDRIVER.getAccessMode(), MEDMEM.GENDRIVER.getFileName(), INTERP_TEST.getResourceFile(), MEDMEM.MESH.getSpaceDimension(), MEDMEM.FIELD_.getSupport(), makeTmpFile(), MEDMEM.MED_DRIVER, test_MEDSPLITTER.meshname, MEDMEM.ASCII_FIELD_DRIVER< T >.open(), MEDMEM.ASCII_FIELD_DRIVER< T >.read(), MEDMEM.GENDRIVER.setFileName(), medClient_test.spaceDimension, MEDMEM.ASCII_FIELD_DRIVER< T >.write(), MEDMEM.SDForSorting< T, SPACEDIMENSION, SORTSTRATEGY >.writeLine(), and MED_EN.WRONLY.

void MEDMEMTest::testConnectivity ( )

void MEDMEMTest::testCoordinate ( )

Check methods (23), defined in MEDMEM_Coordinate.hxx: class COORDINATE { (+) COORDINATE(); (+) COORDINATE(int SpaceDimension, int NumberOfNodes, MED_EN.medModeSwitch Mode); (+) COORDINATE(int SpaceDimension,const string * CoordinateName, const string * CoordinateUnit); (+) COORDINATE(const COORDINATE & m); (+) virtual ~COORDINATE(); (+) void setCoordinates(MEDARRAY<double> *Coordinate,bool shallowCopy=false); (+) void setCoordinates(const MED_EN.medModeSwitch Mode, const double *Coordinate); (+) void setCoordinatesNames(const string * CoordinateName); (+) void setCoordinateName(const string CoordinateName, const int i); (+) void setCoordinatesUnits(const string * CoordinateUnit); (+) void setCoordinateUnit(const string CoordinateUnit, const int i); (+) void setCoordinatesSystem(const string CoordinateSystem); (+) void setNodesNumbers(const int * NodeNumber); (+) int getSpaceDimension() const; (+) int getNumberOfNodes() const; (+) virtual const int* getNodesNumbers() const; (+) string getCoordinatesSystem() const; (+) virtual const double * getCoordinates(MED_EN.medModeSwitch Mode); (+) virtual double getCoordinate(int Number,int Axis); (+) virtual const double * getCoordinateAxis(int Axis); (+) const string * getCoordinatesNames() const; (+) string getCoordinateName(int Axis) const; (+) const string * getCoordinatesUnits() const; (+) string getCoordinateUnit(int Axis) const; }

Use code of MEDMEM/tests/testUCoordinate.cxx MEDMEM/test_copie_coordinate.cxx

void MEDMEMTest::testDriverFactory ( )

Check methods (11), defined in MEDMEM_DriverFactory.hxx: namespace DRIVERFACTORY { (+) MED_EN.medFileVersion getMedFileVersionForWriting(); (+) void setMedFileVersionForWriting(MED_EN.medFileVersion version); (+) driverTypes deduceDriverTypeFromFileName(const std.string & fileName);

(+) GENDRIVER * buildDriverForMesh (driverTypes driverType, const std.string & fileName, MESH *mesh, const string & driverName, MED_EN.med_mode_acces access); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildDriverForField(driverTypes driverType, const std.string & fileName, FIELD<T,INTERLACING_TAG> *fielde, MED_EN.med_mode_acces access); (+) GENDRIVER * buildDriverForMed (driverTypes driverType, const std.string & fileName, MED *mede, MED_EN.med_mode_acces access);

(+) GENDRIVER * buildMedDriverFromFile (const string & fileName, MED * const ptrMed, MED_EN.med_mode_acces access); (+) GENDRIVER * buildMeshDriverFromFile (const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces access); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildFieldDriverFromFile(const string & fileName, FIELD<T,INTERLACING_TAG> * ptrField, MED_EN.med_mode_acces access);

(+) GENDRIVER * buildConcreteMedDriverForMesh(const std.string & fileName, MESH *mesh, const string & driverName, MED_EN.med_mode_acces access, MED_EN.medFileVersion version); (+) template<class T, class INTERLACING_TAG> GENDRIVER * buildConcreteMedDriverForField(const std.string & fileName, FIELD<T,INTERLACING_TAG> *fielde, MED_EN.med_mode_acces access, MED_EN.medFileVersion version); }

void MEDMEMTest::testException ( )

Check methods (not in spec), defined in MEDMEM_Exception.hxx: (+) define LOCALIZED(message) static_cast<const char *> (message) , __FILE__ , __LINE__ class MEDEXCEPTION : public std.exception { (+) MEDEXCEPTION(const char *text, const char *fileName=0, const unsigned int lineNumber=0); (+) MEDEXCEPTION(const MEDEXCEPTION &ex); (+) ~MEDEXCEPTION() throw (); (+) friend ostream & operator<< (ostream &os, const MEDEXCEPTION &ex); (+) virtual const char *what(void) const throw (); } class MED_DRIVER_NOT_FOUND_EXCEPTION : public MEDEXCEPTION { (+) MED_DRIVER_NOT_FOUND_EXCEPTION(const char *text, const char *fileName=0, const unsigned int lineNumber=0); (+) MED_DRIVER_NOT_FOUND_EXCEPTION(const MED_DRIVER_NOT_FOUND_EXCEPTION &ex); (+) ~MED_DRIVER_NOT_FOUND_EXCEPTION() throw(); }

Use code of MEDMEM/tests/testUMedException.cxx

References testGaussLocalization.a, testGaussLocalization.b, TestMedCorba3.d, LOCALIZED, and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testFamily ( )

References check_famille(), MEDMEM.MED_MESH_RDONLY_DRIVER.close(), MEDMEM.SUPPORT.deepCompare(), testDriverAscii.f1, test_NonCoincidentDEC.filename, MEDMEM.FAMILY.getAttributeDescription(), MEDMEM.FAMILY.getAttributeIdentifier(), MEDMEM.FAMILY.getAttributeValue(), MEDMEM.SUPPORT.getDescription(), MEDMEM.SUPPORT.getEntity(), MEDMEM.MESH.getFamily(), MEDMEM.FAMILY.getGroupName(), MEDMEM.FAMILY.getIdentifier(), MEDMEM.SUPPORT.getName(), MEDMEM.FAMILY.getNumberOfAttributes(), MEDMEM.SUPPORT.getNumberOfElements(), MEDMEM.MESH.getNumberOfElementsWithPoly(), MEDMEM.FAMILY.getNumberOfGroups(), MEDMEM.SUPPORT.getNumberOfTypes(), INTERP_TEST.getResourceFile(), MEDMEM.SUPPORT.isOnAllElements(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_FACE, MED_EN.MED_NODE, MED_TAILLE_DESC, MED_TAILLE_LNOM, MEDMEMTest_createTestMesh(), test_MEDSPLITTER.meshname, NULL, MEDMEM.MED_MESH_RDONLY_DRIVER.open(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), TestMedCorba3.s1, MEDMEM.MED_MESH_RDONLY_DRIVER.setMeshName(), and MEDMEM.MESH.setName().

void MEDMEMTest::testField ( )

void MEDMEMTest::testFieldConvert ( )

Check methods (2), defined in MEDMEM_FieldConvert.hxx: (+) template <class t>=""> FIELD<T,FullInterlace> * FieldConvert(const FIELD<T,NoInterlace> & field); (+) template <class t>=""> FIELD<T,NoInterlace> * FieldConvert(const FIELD<T,FullInterlace> & field);

References MEDMEM.FieldConvert(), MEDMEM.FIELD_.getComponentsUnits(), MEDMEM.FIELD_.getComponentUnit(), MEDMEM.UNIT.getName(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValue(), MEDMEM.FIELD< T, INTERLACING_TAG >.setArray(), MEDMEM.FIELD_.setComponentsDescriptions(), MEDMEM.FIELD_.setComponentsNames(), MEDMEM.FIELD_.setComponentsUnits(), MEDMEM.FIELD_.setDescription(), MEDMEM.FIELD_.setMEDComponentsUnits(), MEDMEM.FIELD_.setName(), MEDMEM.FIELD_.setNumberOfComponents(), and MEDMEM.FIELD_.setNumberOfValues().

void MEDMEMTest::testFormulae ( )

Check methods (13), defined in MEDMEM_Formulae.hxx:

(+) inline void CalculateBarycenterDyn(const double **pts, int nbPts, int dim, double *bary);

(+) inline double CalculateAreaForPolyg(const double **coords, int nbOfPtsInPolygs, int spaceDim); (+) inline double CalculateAreaForTria(const double *p1, const double *p2, const double *p3, int spaceDim); (+) inline double CalculateAreaForQuad(const double *p1, const double *p2, const double *p3, const double *p4, int spaceDim);

(+) inline void CalculateNormalForTria(const double *p1, const double *p2, const double *p3, double *normal); (+) inline void CalculateNormalForQuad(const double *p1, const double *p2, const double *p3, const double *p4, double *normal); (+) inline void CalculateNormalForPolyg(const double **coords, int nbOfPtsInPolygs, double *normal);

(+) inline double CalculateVolumeForTetra(const double *p1, const double *p2, const double *p3, const double *p4); (+) inline double CalculateVolumeForPyra(const double *p1, const double *p2, const double *p3, const double *p4, const double *p5); (+) inline double CalculateVolumeForPenta(const double *p1, const double *p2, const double *p3, const double *p4, const double *p5, const double *p6); (+) inline double CalculateVolumeForHexa(const double *pt1, const double *pt2, const double *pt3, const double *pt4, const double *pt5, const double *pt6, const double *pt7, const double *pt8); (+) inline double CalculateVolumeForPolyh(const double ***pts, const int *nbOfNodesPerFaces, int nbOfFaces, const double *bary);

(+) template<int N> inline double addComponentsOfVec(const double **pts, int rk); (+) template<> inline double addComponentsOfVec<1>(const double **pts, int rk);

(+) template<int N, int DIM> inline void CalculateBarycenter(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<2,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<3,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<4,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<5,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<6,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<7,0>(const double **pts, double *bary); (-) template<> inline void CalculateBarycenter<8,0>(const double **pts, double *bary);

void MEDMEMTest::testGaussLocalization ( )

Check methods (13), defined in MEDMEM_GaussLocalization.hxx: class GAUSS_LOCALIZATION_ { (+) virtual MED_EN.medModeSwitch getInterlacingType() const; (+) virtual ~GAUSS_LOCALIZATION_(); } (+) template <class interlacing_tag="FullInterlace"> class GAUSS_LOCALIZATION;

(+) template <class interlacing_tag>=""> ostream & operator<< (ostream &os, const GAUSS_LOCALIZATION<INTERLACING_TAG> &loc);

template <class interlacing_tag>=""> class GAUSS_LOCALIZATION : public GAUSS_LOCALIZATION_ { (+) GAUSS_LOCALIZATION() throw (MEDEXCEPTION); (+) GAUSS_LOCALIZATION(const string & locName, const MED_EN.medGeometryElement typeGeo, const int nGauss, const ArrayNoGauss & cooRef, const ArrayNoGauss & cooGauss, const vector<double> & wg) throw (MEDEXCEPTION); (+) GAUSS_LOCALIZATION(const string & locName, const MED_EN.medGeometryElement typeGeo, const int nGauss, const double * const cooRef, const double * const cooGauss, const double * const wg) throw (MEDEXCEPTION); (+) virtual ~GAUSS_LOCALIZATION();

(+) GAUSS_LOCALIZATION & operator=(const GAUSS_LOCALIZATION & gaussLoc); (+) bool operator == (const GAUSS_LOCALIZATION &loc) const;

(+) string getName() const; (+) MED_EN.medGeometryElement getType() const;

(+) int getNbGauss() const; (+) ArrayNoGauss getRefCoo () const; (+) ArrayNoGauss getGsCoo () const; (+) vector <double> getWeight () const;

(+) inline MED_EN.medModeSwitch getInterlacingType() const; }

References MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getGsCoo(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getInterlacingType(), MEDMEM.GAUSS_LOCALIZATION_.getInterlacingType(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getName(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getNbGauss(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getRefCoo(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getType(), MEDMEM.GAUSS_LOCALIZATION< INTERLACING_TAG >.getWeight(), MED_EN.MED_FULL_INTERLACE, MED_EN.MED_NO_INTERLACE, MED_EN.MED_QUAD4, MED_EN.MED_TRIA3, and MED_EN.MED_UNDEFINED_INTERLACE.

void MEDMEMTest::testGibiMeshDriver ( )

Check methods (31), defined in MEDMEM_GibiMeshDriver.hxx: class GIBI_MESH_DRIVER : public GENDRIVER { (+) GIBI_MESH_DRIVER(); (+) GIBI_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) GIBI_MESH_DRIVER(const GIBI_MESH_DRIVER & driver); (+) virtual ~GIBI_MESH_DRIVER(); (+) virtual void write(void) const = 0; (+) virtual void read (void) = 0; (+) void setMeshName(const string & meshName); (+) string getMeshName() const; (+) static MED_EN.medGeometryElement gibi2medGeom(size_t gibiTypeNb); (+) static int med2gibiGeom(MED_EN.medGeometryElement medGeomType); } class GIBI_MESH_RDONLY_DRIVER : public virtual GIBI_MESH_DRIVER { (+) GIBI_MESH_RDONLY_DRIVER(); (+) GIBI_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_RDONLY_DRIVER(const GIBI_MESH_RDONLY_DRIVER & driver); (+) virtual ~GIBI_MESH_RDONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MESH_WRONLY_DRIVER : public virtual GIBI_MESH_DRIVER { (+) GIBI_MESH_WRONLY_DRIVER(); (+) GIBI_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_WRONLY_DRIVER(const GIBI_MESH_WRONLY_DRIVER & driver); (+) virtual ~GIBI_MESH_WRONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MESH_RDWR_DRIVER : public GIBI_MESH_RDONLY_DRIVER, public GIBI_MESH_WRONLY_DRIVER { (+) GIBI_MESH_RDWR_DRIVER(); (+) GIBI_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (+) GIBI_MESH_RDWR_DRIVER(const GIBI_MESH_RDWR_DRIVER & driver); (+) ~GIBI_MESH_RDWR_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void open(); (+) void close(); } class GIBI_MED_RDONLY_DRIVER : public GIBI_MESH_RDONLY_DRIVER { (+) GIBI_MED_RDONLY_DRIVER(); (+) GIBI_MED_RDONLY_DRIVER(const string & fileName, MED * ptrMed); (+) GIBI_MED_RDONLY_DRIVER(const GIBI_MED_RDONLY_DRIVER & driver); (+) virtual ~GIBI_MED_RDONLY_DRIVER(); (+) void read (void) throw (MEDEXCEPTION); } class GIBI_MED_WRONLY_DRIVER : public GIBI_MESH_WRONLY_DRIVER { (+) GIBI_MED_WRONLY_DRIVER(); (+) GIBI_MED_WRONLY_DRIVER(const string & fileName, MED * ptrMed, MESH * ptrMesh); (+) GIBI_MED_WRONLY_DRIVER(const GIBI_MED_WRONLY_DRIVER & driver); (+) virtual ~GIBI_MED_WRONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); }

void MEDMEMTest::testGrid ( )

Check methods (44), defined in MEDMEM_Grid.hxx: class GRID: public MESH { (+) GRID(); (+) GRID(const MED_EN.med_grid_type type); (BUG:operator=() not implemented but init() not called) GRID(const GRID &m); (+) GRID(driverTypes driverType, const string & fileName="",const string & meshName=""); (+) GRID(const std.vector<std.vector<double> >& xyz_array, const std.vector<std.string>& coord_name, const std.vector<std.string>& coord_unit, const MED_EN.med_grid_type type=MED_ENMED_CARTESIAN); (NOT IMPLEMENTED) GRID & operator=(const GRID &m); (+) virtual ~GRID(); (+) virtual void init(); (tested together with getCoordinateptr() as it is called internally from there first of all. Moreover, fillCoordinates should be made private to avoid ambiguity druing in GRID class usage.) void fillCoordinates() const; (tested together with getConnectivityptr()) void fillConnectivity() const; (+) inline void makeUnstructured();//fill coordinates and connectivity of MESH (+) void fillMeshAfterRead(); (+) void writeUnstructured(int index=0, const string & driverName = ""); (+) void read(int index=0); (+) inline int getNodeNumber(const int i, const int j=0, const int k=0) const; (+) inline int getCellNumber(const int i, const int j=0, const int k=0) const; (+) int getEdgeNumber (const int Axis, const int i, const int j=0, const int k=0) const throw (MEDEXCEPTION); (+) int getFaceNumber (const int Axis, const int i, const int j=0, const int k=0) const throw (MEDEXCEPTION); (+) void getNodePosition(const int Number, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getCellPosition(const int Number, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getEdgePosition (const int Number, int& Axis, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) void getFacePosition (const int Number, int& Axis, int& i, int& j, int& k) const throw (MEDEXCEPTION); (+) inline MED_EN.med_grid_type getGridType() const; (+) int getArrayLength(const int Axis) const throw (MEDEXCEPTION); (+) const double getArrayValue (const int Axis, const int i) const throw (MEDEXCEPTION); (+) inline const COORDINATE * getCoordinateptr() const; (+) inline const double * getCoordinates(MED_EN.medModeSwitch Mode) const; (+) inline const double getCoordinate(int Number,int Axis) const; (+) inline int getNumberOfTypes(MED_EN.medEntityMesh Entity) const; (+) inline int getNumberOfTypesWithPoly(MED_EN.medEntityMesh Entity) const; (+) inline const MED_EN.medGeometryElement * getTypes(MED_EN.medEntityMesh Entity) const; (+) MED_EN.medGeometryElement * getTypesWithPoly(MED_EN.medEntityMesh Entity) const; (+) inline const CELLMODEL * getCellsTypes(MED_EN.medEntityMesh Entity) const; (+) const int * getGlobalNumberingIndex(MED_EN.medEntityMesh Entity) const; (+) inline int getNumberOfElements (MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) inline int getNumberOfElementsWithPoly (MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) inline bool existConnectivity (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline MED_EN.medGeometryElement getElementType (MED_EN.medEntityMesh Entity, int Number) const; (+) inline MED_EN.medGeometryElement getElementTypeWithPoly (MED_EN.medEntityMesh Entity, int Number) const; (+) inline void calculateConnectivity(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline const CONNECTIVITY* getConnectivityptr() const; (+) inline const int * getConnectivity (MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) inline const int * getConnectivityIndex(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline const int * getReverseConnectivity(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) inline const int * getReverseConnectivityIndex(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) inline void setGridType(MED_EN.med_grid_type gridType); }

References MEDMEM.MESH.addDriver(), MEDMEM.MED_MED_RDONLY_DRIVER.close(), testRenumbering.conn, med_test1.Connectivity, medMeshing_test.coordinate, medClient_test.coordinates, coords, medutilities.driver, MEDMEM.CONNECTIVITY.existConnectivity(), test_NonCoincidentDEC.filename, MEDMEM.GRID.getArrayLength(), MEDMEM.GRID.getArrayValue(), MEDMEM.GRID.getCellsTypes(), MEDMEM.GRID.getConnectivityptr(), MEDMEM.COORDINATE.getCoordinate(), MEDMEM.GRID.getCoordinateptr(), MEDMEM.CONNECTIVITY.getElementType(), MEDMEM.CONNECTIVITY.getGlobalNumberingIndex(), MEDMEM.GRID.getGridType(), MEDMEM.MESH.getIsAGrid(), MEDMEM.MED.getMesh(), MEDMEM.MED.getMeshNames(), MEDMEM.GRID.getNumberOfElements(), MEDMEM.MED.getNumberOfMeshes(), MEDMEM.MESH.getNumberOfNodes(), MEDMEM.GRID.getNumberOfTypes(), INTERP_TEST.getResourceFile(), MEDMEM.MESH.getSpaceDimension(), MEDMEM.GRID.getTypes(), med_test_grid.grid_type, med_test_grid.I, MEDMEM.GRID.init(), Med_Gen_test.it, med_test_grid.J, med_test_grid.K, makeTmpFile(), MEDMEM.GRID.makeUnstructured(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_BODY_FITTED, MED_EN.MED_CARTESIAN, MED_EN.MED_CELL, MED_EN.MED_DESCENDING, MEDMEM.MED_DRIVER, MED_EN.MED_EDGE, MED_EN.MED_FACE, MED_EN.MED_FULL_INTERLACE, MED_EN.MED_HEXA8, MED_EN.MED_NODAL, MED_EN.MED_POLAR, MED_EN.MED_QUAD4, MED_EN.MED_SEG2, med_test1.nbEdge, batchmode_medcorba_test.nbMeshes, batchmode_medcorba_test.nbNodes, medClient_test.nbTypesCell, NULL, MEDMEM.MED_MED_RDONLY_DRIVER.open(), MEDMEM.GRID.read(), MEDMEM.MESH.read(), MEDMEM.MED_MED_RDONLY_DRIVER.readFileStruct(), MEDMEMTest_TmpFilesRemover.Register(), med_test1.ReverseConnectivityIndex, MEDMEM.GRID.setGridType(), MEDMEM.MED_MESH_RDONLY_DRIVER.setMeshName(), MEDMEM.MESH.setName(), medClient_test.types, MEDMEM.MEDEXCEPTION.what(), and MEDMEM.GRID.writeUnstructured().

void MEDMEMTest::testGroup ( )

Check methods (10), defined in MEDMEM_Group.hxx: class GROUP : virtual public SUPPORT { (+) GROUP(); (+) GROUP(const string & name, const list<FAMILY*> & family) throw (MEDEXCEPTION); (+) GROUP(const GROUP & m); (+) virtual ~GROUP(); (+) GROUP & operator=(const GROUP &group); (+) friend ostream & operator<<(ostream &os, GROUP &my); (+) inline void setNumberOfFamilies(int numberOfFamilies); (+) inline void setFamilies(vector<FAMILY*> Family); (+) inline int getNumberOfFamilies() const; (+) inline vector<FAMILY*> getFamilies() const; (+) inline FAMILY * getFamily(int i) const; }

References MEDMEM.MED_MESH_RDONLY_DRIVER.close(), test_NonCoincidentDEC.filename, MEDMEM.GROUP.getFamilies(), MEDMEM.GROUP.getFamily(), MEDMEM.MESH.getGroup(), MEDMEM.SUPPORT.getName(), MEDMEM.GROUP.getNumberOfFamilies(), INTERP_TEST.getResourceFile(), MED_EN.MED_NODE, test_MEDSPLITTER.meshname, medMeshing_test.myGroup, NULL, MEDMEM.MED_MESH_RDONLY_DRIVER.open(), MEDMEM.MED_MESH_RDONLY_DRIVER.read(), MEDMEM.GROUP.setFamilies(), MEDMEM.MED_MESH_RDONLY_DRIVER.setMeshName(), MEDMEM.MESH.setName(), and MEDMEM.GROUP.setNumberOfFamilies().

void MEDMEMTest::testIndexCheckingPolicy ( )

Check methods (not in spec), defined in MEDMEM_CellModel.hxx:

Check methods (not in spec), defined in MEDMEM_DriversDef.hxx:

Check methods (not in spec), defined in MEDMEM_DriverTools.hxx:

Check methods (4), defined in MEDMEM_IndexCheckingPolicy.hxx: class IndexCheckPolicy { (+) void checkMoreThanZero(const std.string & classname, int index) const; (+) void checkLessOrEqualThan(const std.string & classname, int max, int index) const; (+) void checkInInclusiveRange(const std.string & classname, int min, int max, int index) const; (+) void checkEquality(const std.string & classname, int a, int b) const; } class NoIndexCheckPolicy { (+) void checkMoreThanZero(const string &classname, int index) const; (+) void checkLessOrEqualThan(const std.string & classname, int max, int index) const; (+) void checkInInclusiveRange(const std.string & classname, int min, int max, int index) const; (+) void checkEquality(const std.string & classname, int a, int b) const; }

References MEDMEM.NoIndexCheckPolicy.checkEquality(), MEDMEM.IndexCheckPolicy.checkEquality(), MEDMEM.NoIndexCheckPolicy.checkInInclusiveRange(), MEDMEM.IndexCheckPolicy.checkInInclusiveRange(), MEDMEM.NoIndexCheckPolicy.checkLessOrEqualThan(), MEDMEM.IndexCheckPolicy.checkLessOrEqualThan(), MEDMEM.NoIndexCheckPolicy.checkMoreThanZero(), and MEDMEM.IndexCheckPolicy.checkMoreThanZero().

void MEDMEMTest::testInit ( )

Check initialization, done in MEDMEM_Init.cxx: (-) MEDMEM.INIT init;

void MEDMEMTest::testMedFieldDriver21 ( )

Check methods (17), defined in MEDMEM_MedFieldDriver21.hxx: template <class t>=""> class MED_FIELD_DRIVER21 : public virtual MED_FIELD_DRIVER<T> { (+) MED_FIELD_DRIVER21(); (+) template <class interlacing_tag>=""> MED_FIELD_DRIVER21(const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField, MED_EN.med_mode_acces accessMode); (+) MED_FIELD_DRIVER21(const MED_FIELD_DRIVER21 & fieldDriver); (+) virtual ~MED_FIELD_DRIVER21(); (+) void open() throw (MEDEXCEPTION); (+) void close(); } template <class t>=""> class MED_FIELD_RDONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T> { (+) MED_FIELD_RDONLY_DRIVER21(); (+) template <class interlacing_tag>=""> MED_FIELD_RDONLY_DRIVER21 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDONLY_DRIVER21(const MED_FIELD_RDONLY_DRIVER21 & fieldDriver); (+) virtual ~MED_FIELD_RDONLY_DRIVER21(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_WRONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> { (+) MED_FIELD_WRONLY_DRIVER21(); (+) template <class interlacing_tag>=""> MED_FIELD_WRONLY_DRIVER21 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_WRONLY_DRIVER21(const MED_FIELD_WRONLY_DRIVER21 & fieldDriver); (+) virtual ~MED_FIELD_WRONLY_DRIVER21(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_RDWR_DRIVER21 : public MED_FIELD_RDONLY_DRIVER21<T>, public MED_FIELD_WRONLY_DRIVER21<T>, public IMED_FIELD_RDWR_DRIVER<T> { (+) MED_FIELD_RDWR_DRIVER21(); (+) template <class interlacing_tag>=""> MED_FIELD_RDWR_DRIVER21 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDWR_DRIVER21(const MED_FIELD_RDWR_DRIVER21 & fieldDriver); (+) ~MED_FIELD_RDWR_DRIVER21(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); }

void MEDMEMTest::testMedFieldDriver22 ( )

Check methods (17), defined in MEDMEM_MedFieldDriver22.hxx: template <class t>=""> class MED_FIELD_DRIVER22 : public virtual MED_FIELD_DRIVER<T> { (+) MED_FIELD_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_DRIVER22(const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField, MED_EN.med_mode_acces accessMode); (+) MED_FIELD_DRIVER22(const MED_FIELD_DRIVER22 & fieldDriver); (+) virtual ~MED_FIELD_DRIVER22(); (+) void open() throw (MEDEXCEPTION); (+) void close(); } template <class t>=""> class MED_FIELD_RDONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T> { (+) MED_FIELD_RDONLY_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_RDONLY_DRIVER22 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDONLY_DRIVER22(const MED_FIELD_RDONLY_DRIVER22 & fieldDriver); (+) virtual ~MED_FIELD_RDONLY_DRIVER22(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_WRONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> { (+) MED_FIELD_WRONLY_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_WRONLY_DRIVER22 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_WRONLY_DRIVER22(const MED_FIELD_WRONLY_DRIVER22 & fieldDriver); (+) virtual ~MED_FIELD_WRONLY_DRIVER22(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } template <class t>=""> class MED_FIELD_RDWR_DRIVER22 : public MED_FIELD_RDONLY_DRIVER22<T>, public MED_FIELD_WRONLY_DRIVER22<T>, public IMED_FIELD_RDWR_DRIVER<T> { (+) MED_FIELD_RDWR_DRIVER22(); (+) template <class interlacing_tag>=""> MED_FIELD_RDWR_DRIVER22 (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField); (+) MED_FIELD_RDWR_DRIVER22(const MED_FIELD_RDWR_DRIVER22 & fieldDriver); (+) ~MED_FIELD_RDWR_DRIVER22(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); }

References MEDMEM.MED_FIELD_DRIVER22< T >.close(), test_MEDSPLITTER.filename_rd, MEDMEM.MED_FIELD_DRIVER< T >.getFieldName(), INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEM.MED_FIELD_DRIVER22< T >.open(), MEDMEM.MED_FIELD_RDWR_DRIVER22< T >.read(), MEDMEM.MED_FIELD_RDONLY_DRIVER22< T >.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.MED_FIELD_DRIVER< T >.setFieldName(), MEDMEM.FIELD_.setName(), MEDMEM.MEDEXCEPTION.what(), MEDMEM.MED_FIELD_RDWR_DRIVER22< T >.write(), MEDMEM.MED_FIELD_WRONLY_DRIVER22< T >.write(), and MEDMEM.MED_FIELD_RDONLY_DRIVER22< T >.write().

void MEDMEMTest::testReadFieldOnNodesAndCells ( )

0020582: [CEA 368] MEDMEM don't work with a same field on NODES and CELLS Before fixing the issue there was the error: RuntimeError: MED Exception in .../MED_SRC/src/MEDMEM/MEDMEM_MedFieldDriver22.hxx [503] : MED_FIELD_DRIVER<T>.createFieldSupportPart1(...) Field |field on NODEs and CELLs| with (ndt,or) = (-1,-1) must not be defined on different entity types

References MEDMEM.FIELD< T, INTERLACING_TAG >.addDriver(), Med_Gen_test.fieldName, MEDMEM.SUPPORT.getEntity(), MEDMEM.FIELD_.getSupport(), MEDMEM.FIELD< T, INTERLACING_TAG >.getValueIJ(), makeTmpFile(), MED_EN.MED_ALL_ELEMENTS, MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_NODE, MEDMEMTest_createTestMesh(), MED_test2.mesh, medMeshing_test.numberOfCells, medClient_test.numberOfNodes, MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.FIELD_.setComponentDescription(), MEDMEM.FIELD_.setComponentName(), MEDMEM.FIELD_.setMEDComponentUnit(), MEDMEM.FIELD_.setName(), MEDMEM.FIELD< T, INTERLACING_TAG >.setValue(), medMeshing_test.supportOnCells, medMeshing_test.supportOnNodes, and MEDMEM.FIELD< T, INTERLACING_TAG >.write().

void MEDMEMTest::testMed ( )

Check methods (26), defined in MEDMEM_Med.hxx: class MED { (+) MED(); (+) MED (driverTypes driverType, const string & fileName); (+) ~MED(); (+) void addField (FIELD_ * const ptrField) throw (MED_EXCEPTION); (+) void addMesh (MESH * const ptrMesh) throw (MED_EXCEPTION); (+) int addDriver (driverTypes driverType, const string & fileName, MED_EN.med_mode_acces access=MED_ENMED_REMP); (+) int addDriver (GENDRIVER & driver); (+) void rmDriver (int index=0) throw (MEDEXCEPTION); (+) void readFileStruct(int index=0) throw (MEDEXCEPTION); (+) void read (int index=0) throw (MEDEXCEPTION); (+) void writeFrom (int index=0) throw (MEDEXCEPTION); (+) void write (int index=0) throw (MEDEXCEPTION); (+) int getNumberOfMeshes (void) const; (+) int getNumberOfFields (void) const; (+) void getMeshNames (string * meshNames) const throw (MEDEXCEPTION); (+) deque<string> getMeshNames () const; (+) MESH * getMesh (const string & meshName) const throw (MEDEXCEPTION); (+) MESH * getMesh (const FIELD_ * const field) const throw (MEDEXCEPTION); (+) void getFieldNames (string * fieldNames) const throw (MEDEXCEPTION); (+) deque<string> getFieldNames () const; (+) deque<DT_IT_> getFieldIteration (const string & fieldName) const throw (MEDEXCEPTION); (+) FIELD_ * getField (const string & fieldName, const int dt, const int it) const throw (MEDEXCEPTION); (NOT COMPILABLE!!!) template<class T> FIELD<T> * getFieldT (const string & fieldName, const int dt, const int it) const throw (MEDEXCEPTION); (+) FIELD_ * getField2 (const string & fieldName, double time, int it=0) const throw (MEDEXCEPTION); (+) const map<MED_EN.medEntityMesh,SUPPORT *> & getSupports (const string & meshName) const throw (MEDEXCEPTION); (+) SUPPORT * getSupport (const string & meshName, MED_EN.medEntityMesh entity) const throw (MEDEXCEPTION); (-, as it is temporary and called from driver after Med object reading from file) void updateSupport (); }

References MEDMEM.MED.addDriver(), MEDMEM.DRIVERFACTORY.buildDriverForMed(), MEDMEM.MESH.deepCompare(), MEDMEM.SUPPORT.deepCompare(), medutilities.driver, test_NonCoincidentDEC.filename, MEDMEM.MESH.getCoordinateptr(), MEDMEM.FIELD_.getDescription(), MEDMEM.MED.getField(), MEDMEM.MED.getField2(), MEDMEM.MED.getFieldIteration(), MEDMEM.MED.getFieldNames(), MEDMEM.MED.getMesh(), MEDMEM.MED.getMeshNames(), MEDMEM.FIELD_.getNumberOfComponents(), MEDMEM.MED.getNumberOfFields(), MEDMEM.MED.getNumberOfMeshes(), MEDMEM.MESH.getNumberOfNodes(), MEDMEM.FIELD_.getNumberOfValues(), INTERP_TEST.getResourceFile(), MEDMEM.MESH.getSpaceDimension(), MEDMEM.MED.getSupport(), MEDMEM.FIELD_.getSupport(), MEDMEM.MED.getSupports(), MEDMEM.FIELD_.getTime(), MEDMEM.FIELD_.getValueType(), medMeshing_test.idMedV21, makeTmpFile(), MED_EN.MED_CELL, MEDMEM.MED_DRIVER, MED_EN.MED_INT32, MED_EN.MED_INVALID, MED_EN.MED_REEL64, MEDMEMTest_createTestMesh(), batchmode_medcorba_test.nbFields, batchmode_medcorba_test.nbMeshes, NULL, MED_EN.RDONLY, MEDMEM.MED.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.MED.rmDriver(), medClient_test.type, MEDMEM.MEDEXCEPTION.what(), MEDMEM.MED.write(), and MEDMEM.MED.writeFrom().

void MEDMEMTest::testMedMedDriver21 ( )

Check methods (21), defined in MEDMEM_MedMedDriver21.hxx: class MED_MED_DRIVER21 : public virtual MED_MED_DRIVER { (+) MED_MED_DRIVER21(); (+) MED_MED_DRIVER21(const string & fileName, MED * const ptrMed); (+) MED_MED_DRIVER21(const string & fileName, MED * const ptrMed, MED_EN.med_mode_acces accessMode); (+) MED_MED_DRIVER21(const MED_MED_DRIVER21 & driver); (+) virtual ~MED_MED_DRIVER21(); (+) void open() throw (MEDEXCEPTION); (+) void close(); (+) virtual void write (void) const; (+) virtual void writeFrom (void) const; (+) virtual void read (void); (+) virtual void readFileStruct (void); } class MED_MED_RDONLY_DRIVER21 : public virtual IMED_MED_RDONLY_DRIVER, public virtual MED_MED_DRIVER21 { (+) MED_MED_RDONLY_DRIVER21(); (+) MED_MED_RDONLY_DRIVER21(const string & fileName, MED * const ptrMed); (+) MED_MED_RDONLY_DRIVER21(const MED_MED_RDONLY_DRIVER21 & driver); (+) virtual ~MED_MED_RDONLY_DRIVER21(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); } class MED_MED_WRONLY_DRIVER21 : public virtual IMED_MED_WRONLY_DRIVER, public virtual MED_MED_DRIVER21 { (+) MED_MED_WRONLY_DRIVER21(); (+) MED_MED_WRONLY_DRIVER21(const string & fileName, MED * const ptrMed); (+) MED_MED_WRONLY_DRIVER21(const MED_MED_WRONLY_DRIVER21 & driver); (+) virtual ~MED_MED_WRONLY_DRIVER21(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); } class MED_MED_RDWR_DRIVER21 : public MED_MED_RDONLY_DRIVER21, public MED_MED_WRONLY_DRIVER21, public IMED_MED_RDWR_DRIVER { (+) MED_MED_RDWR_DRIVER21(); (+) MED_MED_RDWR_DRIVER21(const string & fileName, MED * const ptrMed); (+) MED_MED_RDWR_DRIVER21(const MED_MED_RDWR_DRIVER21 & driver); (+) ~MED_MED_RDWR_DRIVER21(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); }

!!! do not make troubles for the user

References test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEM.MED_MED_DRIVER21.open(), MEDMEMTest_TmpFilesRemover.Register(), and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testMedMedDriver22 ( )

Check methods (21), defined in MEDMEM_MedMedDriver22.hxx: class MED_MED_DRIVER22 : public virtual MED_MED_DRIVER { (+) MED_MED_DRIVER22(); (+) MED_MED_DRIVER22(const string & fileName, MED * const ptrMed); (+) MED_MED_DRIVER22(const string & fileName, MED * const ptrMed, MED_EN.med_mode_acces accessMode); (+) MED_MED_DRIVER22(const MED_MED_DRIVER22 & driver); (+) virtual ~MED_MED_DRIVER22(); (+) void open() throw (MEDEXCEPTION); (+) void close(); (+) virtual void write (void) const; (+) virtual void writeFrom (void) const; (+) virtual void read (void); (+) virtual void readFileStruct (void); } class MED_MED_RDONLY_DRIVER22 : public virtual IMED_MED_RDONLY_DRIVER, public virtual MED_MED_DRIVER22 { (+) MED_MED_RDONLY_DRIVER22(); (+) MED_MED_RDONLY_DRIVER22(const string & fileName, MED * const ptrMed); (+) MED_MED_RDONLY_DRIVER22(const MED_MED_RDONLY_DRIVER22 & driver); (+) virtual ~MED_MED_RDONLY_DRIVER22(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); } class MED_MED_WRONLY_DRIVER22 : public virtual IMED_MED_WRONLY_DRIVER, public virtual MED_MED_DRIVER22 { (+) MED_MED_WRONLY_DRIVER22(); (+) MED_MED_WRONLY_DRIVER22(const string & fileName, MED * const ptrMed); (+) MED_MED_WRONLY_DRIVER22(const MED_MED_WRONLY_DRIVER22 & driver); (+) virtual ~MED_MED_WRONLY_DRIVER22(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); } class MED_MED_RDWR_DRIVER22 : public virtual MED_MED_RDONLY_DRIVER22, public virtual MED_MED_WRONLY_DRIVER22, public virtual IMED_MED_RDWR_DRIVER { (+) MED_MED_RDWR_DRIVER22(); (+) MED_MED_RDWR_DRIVER22(const string & fileName, MED * const ptrMed); (+) MED_MED_RDWR_DRIVER22(const MED_MED_RDWR_DRIVER22 & driver); (+) ~MED_MED_RDWR_DRIVER22(); (+) void write (void) const throw (MEDEXCEPTION); (+) void writeFrom (void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void readFileStruct (void) throw (MEDEXCEPTION); }

!!! do not make troubles for the user

References test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEM.MED_MED_DRIVER22.open(), MEDMEMTest_TmpFilesRemover.Register(), and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testMedMeshDriver21 ( )

Check methods (13), defined in MEDMEM_MedMeshDriver21.hxx: class MED_MESH_DRIVER21 : public virtual MED_MESH_DRIVER { (+) MED_MESH_DRIVER21(); (+) MED_MESH_DRIVER21(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) MED_MESH_DRIVER21(const MED_MESH_DRIVER21 & driver); (+) virtual ~MED_MESH_DRIVER21(); (+) void open(); (+) void close(); } class MED_MESH_RDONLY_DRIVER21 : public virtual IMED_MESH_RDONLY_DRIVER, public virtual MED_MESH_DRIVER21 { (+) MED_MESH_RDONLY_DRIVER21(); (+) MED_MESH_RDONLY_DRIVER21(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDONLY_DRIVER21(const MED_MESH_RDONLY_DRIVER21 & driver); (+) virtual ~MED_MESH_RDONLY_DRIVER21(); (+) void read (void); } class MED_MESH_WRONLY_DRIVER21 : public virtual IMED_MESH_WRONLY_DRIVER, public virtual MED_MESH_DRIVER21 { (+) MED_MESH_WRONLY_DRIVER21(); (+) MED_MESH_WRONLY_DRIVER21(const string & fileName, MESH * ptrMesh); (+) MED_MESH_WRONLY_DRIVER21(const MED_MESH_WRONLY_DRIVER21 & driver); (+) virtual ~MED_MESH_WRONLY_DRIVER21(); (+) void write(void) const; } class MED_MESH_RDWR_DRIVER21 : public IMED_MESH_RDWR_DRIVER, public MED_MESH_RDONLY_DRIVER21, public MED_MESH_WRONLY_DRIVER21 { (+) MED_MESH_RDWR_DRIVER21(); (+) MED_MESH_RDWR_DRIVER21(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDWR_DRIVER21(const MED_MESH_RDWR_DRIVER21 & driver); (+) ~MED_MESH_RDWR_DRIVER21(); (+) void write(void) const; (+) void read (void); }

References MEDMEM.MED_MESH_DRIVER21.close(), test_MEDSPLITTER.filename_rd, MEDMEM.MED_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), MED_TAILLE_NOM, test_MEDSPLITTER.meshname, MEDMEM.MED_MESH_DRIVER21.open(), MEDMEM.MED_MESH_RDWR_DRIVER21.read(), MEDMEM.IMED_MESH_WRONLY_DRIVER.read(), MEDMEM.MED_MESH_RDONLY_DRIVER21.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.MESH.setName(), MEDMEM.MEDEXCEPTION.what(), MEDMEM.MED_MESH_RDWR_DRIVER21.write(), and MEDMEM.MED_MESH_WRONLY_DRIVER21.write().

void MEDMEMTest::testMedMeshDriver22 ( )

Check methods (13), defined in MEDMEM_MedMeshDriver22.hxx: class MED_MESH_DRIVER22 : public virtual MED_MESH_DRIVER { (+) MED_MESH_DRIVER22(); (+) MED_MESH_DRIVER22(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) MED_MESH_DRIVER22(const MED_MESH_DRIVER22 & driver); (+) virtual ~MED_MESH_DRIVER22(); (+) void open(); (+) void close(); } class MED_MESH_RDONLY_DRIVER22 : public virtual IMED_MESH_RDONLY_DRIVER, public virtual MED_MESH_DRIVER22 { (+) MED_MESH_RDONLY_DRIVER22(); (+) MED_MESH_RDONLY_DRIVER22(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDONLY_DRIVER22(const MED_MESH_RDONLY_DRIVER22 & driver); (+) virtual ~MED_MESH_RDONLY_DRIVER22(); (+) void read (void); } class MED_MESH_WRONLY_DRIVER22 : public virtual IMED_MESH_WRONLY_DRIVER, public virtual MED_MESH_DRIVER22 { (+) MED_MESH_WRONLY_DRIVER22(); (+) MED_MESH_WRONLY_DRIVER22(const string & fileName, MESH * ptrMesh); (+) MED_MESH_WRONLY_DRIVER22(const MED_MESH_WRONLY_DRIVER22 & driver); (+) virtual ~MED_MESH_WRONLY_DRIVER22(); (+) void write(void) const; } class MED_MESH_RDWR_DRIVER22 : public IMED_MESH_RDWR_DRIVER, public MED_MESH_RDONLY_DRIVER22, public MED_MESH_WRONLY_DRIVER22 { (+) MED_MESH_RDWR_DRIVER22(); (+) MED_MESH_RDWR_DRIVER22(const string & fileName, MESH * ptrMesh); (+) MED_MESH_RDWR_DRIVER22(const MED_MESH_RDWR_DRIVER22 & driver); (+) ~MED_MESH_RDWR_DRIVER22(); (+) void write(void) const; (+) void read (void); }

References MEDMEM.MED_MESH_DRIVER22.close(), test_MEDSPLITTER.filename_rd, MEDMEM.MED_MESH_DRIVER.getMeshName(), INTERP_TEST.getResourceFile(), makeTmpFile(), MED_TAILLE_NOM, test_MEDSPLITTER.meshname, MEDMEM.MED_MESH_DRIVER22.open(), MEDMEM.MED_MESH_RDWR_DRIVER22.read(), MEDMEM.IMED_MESH_WRONLY_DRIVER.read(), MEDMEM.MED_MESH_RDONLY_DRIVER22.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.MED_MESH_DRIVER.setMeshName(), MEDMEM.MESH.setName(), MEDMEM.MEDEXCEPTION.what(), MEDMEM.MED_MESH_RDWR_DRIVER22.write(), and MEDMEM.MED_MESH_WRONLY_DRIVER22.write().

void MEDMEMTest::testMedVersion ( )

Check methods (not in spec), defined in MEDMEM_MedVersion.hxx: (+) MED_EN.medFileVersion getMedFileVersion(const string & fileName) throw (MEDEXCEPTION); (+) int getMedAccessMode(MED_EN.med_mode_acces mode, MED_EN.medFileVersion medVersion) throw (MEDEXCEPTION);

References test_NonCoincidentDEC.filename, MEDMEM.getMedAccessMode(), MEDMEM.getMedFileVersion(), INTERP_TEST.getResourceFile(), med_2_1.MED_ECRI, MED_EN.RDWR, MED_EN.V21, and MEDMEM.MEDEXCEPTION.what().

void MEDMEMTest::testMeshAndMeshing ( )

Check methods (18), defined in MEDMEM_Meshing.hxx: class MESHING: public MESH { (+) MESHING(); (+) ~MESHING(); (+) void setSpaceDimension (const int SpaceDimension); (+) void setMeshDimension (const int MeshDimension); (+) void setNumberOfNodes (const int NumberOfNodes); (+) void setCoordinates (const int SpaceDimension, const int NumberOfNodes, const double * Coordinates, const string System, const MED_EN.medModeSwitch Mode); (+) void setCoordinatesSystem(const string System) throw (MEDEXCEPTION); (+) void setCoordinatesNames (const string * names); (+) void setCoordinateName (const string name, const int i); (+) void setCoordinatesUnits (const string * units); (+) void setCoordinateUnit (const string unit, const int i); (+) void setNumberOfTypes (const int NumberOfTypes, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setTypes (const MED_EN.medGeometryElement * Types, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setNumberOfElements (const int * NumberOfElements, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setConnectivity (const int * Connectivity, const MED_EN.medEntityMesh Entity, const MED_EN.medGeometryElement Type) throw (MEDEXCEPTION); (+) void setPolygonsConnectivity (const int * ConnectivityIndex, const int * ConnectivityValue, int nbOfPolygons, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void setPolyhedraConnectivity (const int * PolyhedronIndex, const int * FacesIndex, const int * Nodes, int nbOfPolyhedra, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (NOT YET IMPLEMENTED!!!) void setConnectivities (const int * ConnectivityIndex, const int * ConnectivityValue, const MED_EN.medConnectivity ConnectivityType, const MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) void addGroup (const GROUP & Group) throw (MEDEXCEPTION); }

Check methods (87), defined in MEDMEM_Mesh.hxx: class MESH : public RCBASE { (+) void init(); (+) MESH(); (+) MESH(MESH &m); (+) MESH & operator=(const MESH &m); (+) virtual bool operator==(const MESH& other) const; (+) virtual bool deepCompare(const MESH& other) const; (+) MESH(driverTypes driverType, const string & fileName="", const string & meshName="") throw (MEDEXCEPTION); (+) virtual ~MESH(); (+) friend ostream & operator<<(ostream &os, const MESH &my); (+) int addDriver(driverTypes driverType, const string & fileName="Default File Name.med", const string & driverName="Default Mesh Name", MED_EN.med_mode_acces access=MED_ENMED_REMP); (+) int addDriver(GENDRIVER & driver); (+) void rmDriver(int index=0); (+) virtual void read(int index=0); (must be private) inline void read(const GENDRIVER & genDriver); (+) inline void write(int index=0, const string & driverName = ""); (must be private) inline void write(const GENDRIVER & genDriver); (+) inline void setName(string name); (+) inline void setDescription(string description); (+) inline string getName() const; (+) inline string getDescription() const; (+) inline int getSpaceDimension() const; (+) inline int getMeshDimension() const; (+) inline bool getIsAGrid(); (+) inline int getNumberOfNodes() const; (+) virtual inline const COORDINATE * getCoordinateptr() const; (+) inline string getCoordinatesSystem() const; (+) virtual inline const double * getCoordinates(MED_EN.medModeSwitch Mode) const; (+) virtual inline const double getCoordinate(int Number,int Axis) const; (+) inline const string * getCoordinatesNames() const; (+) inline const string * getCoordinatesUnits() const; (+) virtual inline int getNumberOfTypes(MED_EN.medEntityMesh Entity) const; (+) virtual int getNumberOfTypesWithPoly(MED_EN.medEntityMesh Entity) const; (+) virtual inline const MED_EN.medGeometryElement * getTypes(MED_EN.medEntityMesh Entity) const; (+) virtual MED_EN.medGeometryElement * getTypesWithPoly(MED_EN.medEntityMesh Entity) const; (+) virtual inline const CELLMODEL * getCellsTypes(MED_EN.medEntityMesh Entity) const; (+) virtual inline string * getCellTypeNames(MED_EN.medEntityMesh Entity) const; (+) virtual const int * getGlobalNumberingIndex(MED_EN.medEntityMesh Entity) const; (+) virtual inline int getNumberOfElements(MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual int getNumberOfElementsWithPoly(MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline bool existConnectivity(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline bool existPolygonsConnectivity(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline bool existPolyhedronConnectivity(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) virtual inline MED_EN.medGeometryElement getElementType (MED_EN.medEntityMesh Entity, int Number) const; (+) virtual inline MED_EN.medGeometryElement getElementTypeWithPoly (MED_EN.medEntityMesh Entity, int Number) const; (+) virtual inline void calculateConnectivity(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) virtual inline int getConnectivityLength(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline const int * getConnectivity(MED_EN.medModeSwitch Mode, MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type) const; (+) virtual inline const int * getConnectivityIndex (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline int getPolygonsConnectivityLength (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline const int * getPolygonsConnectivity (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline const int * getPolygonsConnectivityIndex (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity) const; (+) inline int getNumberOfPolygons(MED_EN.medEntityMesh Entity=MED_ENMED_ALL_ENTITIES) const; (+) inline int getPolyhedronConnectivityLength(MED_EN.medConnectivity ConnectivityType) const; (+) inline const int * getPolyhedronConnectivity(MED_EN.medConnectivity ConnectivityType) const; (+) inline const int * getPolyhedronFacesIndex() const; (+) inline const int * getPolyhedronIndex(MED_EN.medConnectivity ConnectivityType) const; (+) inline int getNumberOfPolyhedronFaces() const; (+) inline int getNumberOfPolyhedron() const; (+) virtual int getElementNumber(MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity, MED_EN.medGeometryElement Type, int * connectivity) const; (+) virtual inline int getReverseConnectivityLength (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) virtual inline const int * getReverseConnectivity (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) virtual inline int getReverseConnectivityIndexLength (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) virtual inline const int * getReverseConnectivityIndex (MED_EN.medConnectivity ConnectivityType, MED_EN.medEntityMesh Entity=MED_ENMED_CELL) const; (+) virtual int getNumberOfFamilies(MED_EN.medEntityMesh Entity) const; (+) virtual inline const vector<FAMILY*> getFamilies(MED_EN.medEntityMesh Entity) const; (+) virtual inline const FAMILY* getFamily(MED_EN.medEntityMesh Entity,int i) const; (+) virtual int getNumberOfGroups(MED_EN.medEntityMesh Entity) const; (+) virtual inline const vector<GROUP*> getGroups(MED_EN.medEntityMesh Entity) const; (+) virtual inline const GROUP* getGroup(MED_EN.medEntityMesh Entity,int i) const; (+) virtual inline const CONNECTIVITY* getConnectivityptr() const; (+) virtual SUPPORT * getBoundaryElements(MED_EN.medEntityMesh Entity) throw (MEDEXCEPTION); (+) SUPPORT * getSkin(const SUPPORT * Support3D) throw (MEDEXCEPTION); (+) virtual FIELD<double>* getVolume (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getArea (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getLength (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getNormal (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) virtual FIELD<double>* getBarycenter (const SUPPORT * Support) const throw (MEDEXCEPTION); (+) static SUPPORT * mergeSupports(const vector<SUPPORT *> Supports) throw (MEDEXCEPTION); (+) static SUPPORT * intersectSupports(const vector<SUPPORT *> Supports) throw (MEDEXCEPTION); (+) void createFamilies(); (+) SUPPORT *buildSupportOnNodeFromElementList (const list<int>& listOfElt, MED_EN.medEntityMesh entity) const throw (MEDEXCEPTION); (do the same thing as buildSupportOnNodeFromElementList except that a SUPPORT is not created) void fillSupportOnNodeFromElementList (const list<int>& listOfElt, SUPPORT *supportToFill) const throw (MEDEXCEPTION); (+) SUPPORT *buildSupportOnElementsFromElementList (const list<int>& listOfElt, MED_EN.medEntityMesh entity) const throw (MEDEXCEPTION); (+) int getElementContainingPoint(const double *coord); (+) vector< vector<double> > getBoundingBox() const; (+) template<class T> static FIELD<T> * mergeFields(const vector< FIELD<T> * > & others, bool meshCompare=false); (Presently disconnected in C++) virtual void addReference() const; (Presently disconnected in C++) virtual void removeReference() const; }

void MEDMEMTest::testModulusArray ( )

Check methods (4), defined in MEDMEM_ModulusArray.hxx: class MEDMODULUSARRAY { (+) MEDMODULUSARRAY(int length, const int * array); (+) MEDMODULUSARRAY(int vertexLength, int totalLength, const int * array); (+) ~MEDMODULUSARRAY(); (+) const int operator[](const int &i) const; (+) int compare(const MEDMODULUSARRAY &modulusArray) const; }

References MEDMEM.MEDMODULUSARRAY.compare(), and testMEDMEM.ret.

void MEDMEMTest::testnArray ( )

Check methods (21), defined in MEDMEM_nArray.hxx: class MEDMEM_Array_ { (-) virtual bool getGaussPresence() const { return false; } (-) virtual MED_EN.medModeSwitch getInterlacingType() const {return MED_EN.MED_UNDEFINED_INTERLACE;} (+) ~MEDMEM_Array_() {}; } template<class ARRAY_ELEMENT_TYPE, class INTERLACING_POLICY=FullInterlaceNoGaussPolicy, class CHECKING_POLICY=IndexCheckPolicy> class MEDMEM_Array : public INTERLACING_POLICY, public CHECKING_POLICY, public MEDMEM_Array_ { (+) MEDMEM_Array(); (+) ~MEDMEM_Array(); (+) inline MEDMEM_Array(int dim, int nbelem); (+) inline MEDMEM_Array(ElementType * values, int dim, int nbelem, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline MEDMEM_Array(int dim, int nbelem, int nbtypegeo, const int * const nbelgeoc, const int * const nbgaussgeo); (+) inline MEDMEM_Array(ElementType * values, int dim, int nbelem, int nbtypegeo, const int * const nbelgeoc, const int * const nbgaussgeo, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline MEDMEM_Array(const MEDMEM_Array & array, bool shallowCopy=false); (+) inline MEDMEM_Array<ElementType,InterlacingPolicy,CheckingPolicy> & operator=(const MEDMEM_Array & array); (+) MED_EN.medModeSwitch getInterlacingType() const; (+) bool getGaussPresence() const; (+) ElementType * getPtr(); (+) void setPtr(ElementType * values, bool shallowCopy=false, bool ownershipOfValues=false); (+) inline const ElementType * getRow(int i) const; (+) void setRow(int i,const ElementType * const value); (+) inline const ElementType * getColumn(int j) const; (+) void setColumn(int j, const ElementType * const value); (+) inline const ElementType & getIJ(int i, int j) const; (+) inline const ElementType & getIJK(int i, int j, int k) const; (+) inline void setIJ(int i, int j, const ElementType & value); (+) inline void setIJK(int i, int j, int k, const ElementType & value); (+) bool operator == (const MEDMEM_Array & array) const; (+) friend ostream & operator<<(ostream & os, const MEDMEM_Array & array); }

void MEDMEMTest::testPartialDescendingConnectivity ( )

void MEDMEMTest::testPointerOf ( )

Check methods (12), defined in MEDMEM_PointerOf.hxx: template <typename t>=""> class PointerOf { (+) PointerOf(); (+) ~PointerOf(); (+) PointerOf(const int &size); (+) PointerOf(const T *pointer); (+) PointerOf(const int &size, const T *pointer); (+) PointerOf(const PointerOf<T> & pointerOf); (NOT COMPILABLE!!!) PointerOf(const int &size, const PointerOf<T> & pointerOf); (+) operator T*(); (+) operator const T*() const; (+) void set(const int &size); (+) void set(const T *pointer); (+) void set(const int &size, const T *pointer); (+) void setShallowAndOwnership(const T *pointer); (+) PointerOf<T>& operator=(const PointerOf<T> &pointer); }

References NULL, SCRUTE_MED, MEDMEM.PointerOf< T >.set(), MEDMEM.PointerOf< T >.setShallowAndOwnership(), and test_NonCoincidentDEC.size.

void MEDMEMTest::testPolyhedronArray ( )

Check methods (12), defined in MEDMEM_PolyhedronArray.hxx: class POLYHEDRONARRAY { (+) POLYHEDRONARRAY(); (+) POLYHEDRONARRAY(MED_EN.med_int numberofpolyhedron, MED_EN.med_int numberoffaces, MED_EN.med_int numberofnodes); (+) POLYHEDRONARRAY(const POLYHEDRONARRAY& m);

(+) inline MED_EN.med_int getNumberOfPolyhedron() const; (+) inline MED_EN.med_int getNumberOfFaces() const; (+) inline MED_EN.med_int getNumberOfNodes() const;

(+) inline const MED_EN.med_int* getPolyhedronIndex() const; (+) inline const MED_EN.med_int* getFacesIndex() const; (+) inline const MED_EN.med_int* getNodes() const;

(+) inline void setPolyhedronIndex(const MED_EN.med_int* polyhedronindex); (+) inline void setFacesIndex(const MED_EN.med_int* facesindex); (+) inline void setNodes(const MED_EN.med_int* nodes); }

References MEDMEM.POLYHEDRONARRAY.getFacesIndex(), MEDMEM.POLYHEDRONARRAY.getNodes(), MEDMEM.POLYHEDRONARRAY.getNumberOfFaces(), MEDMEM.POLYHEDRONARRAY.getNumberOfNodes(), MEDMEM.POLYHEDRONARRAY.getNumberOfPolyhedron(), MEDMEM.POLYHEDRONARRAY.getPolyhedronIndex(), batchmode_medcorba_test.nbNodes, nodes, NULL, MEDMEM.POLYHEDRONARRAY.setFacesIndex(), MEDMEM.POLYHEDRONARRAY.setNodes(), and MEDMEM.POLYHEDRONARRAY.setPolyhedronIndex().

void MEDMEMTest::testPorflowMeshDriver ( )

Check methods (18), defined in MEDMEM_PorflowMeshDriver.hxx: class PORFLOW_MESH_DRIVER : public GENDRIVER { (+) PORFLOW_MESH_DRIVER(); (+) PORFLOW_MESH_DRIVER(const string & fileName, MESH * ptrMesh, MED_EN.med_mode_acces accessMode); (+) PORFLOW_MESH_DRIVER(const PORFLOW_MESH_DRIVER & driver); (+) virtual ~PORFLOW_MESH_DRIVER(); (+) void open() throw (MEDEXCEPTION); (+) void close() throw (MEDEXCEPTION); (-) virtual void write(void) const = 0; (+) virtual void read (void) = 0; (+) void setMeshName(const string & meshName); (+) string getMeshName() const; } class PORFLOW_MESH_RDONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER { (+) PORFLOW_MESH_RDONLY_DRIVER(); (+) PORFLOW_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_RDONLY_DRIVER(const PORFLOW_MESH_RDONLY_DRIVER & driver); (+) virtual ~PORFLOW_MESH_RDONLY_DRIVER(); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } class PORFLOW_MESH_WRONLY_DRIVER : public virtual PORFLOW_MESH_DRIVER { (+) PORFLOW_MESH_WRONLY_DRIVER(); (+) PORFLOW_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_WRONLY_DRIVER(const PORFLOW_MESH_WRONLY_DRIVER & driver); (+) virtual ~PORFLOW_MESH_WRONLY_DRIVER(); (NOT IMPLEMENTED!!!) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); } class PORFLOW_MESH_RDWR_DRIVER : public PORFLOW_MESH_RDONLY_DRIVER, public PORFLOW_MESH_WRONLY_DRIVER { (+) PORFLOW_MESH_RDWR_DRIVER(); (+) PORFLOW_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (+) PORFLOW_MESH_RDWR_DRIVER(const PORFLOW_MESH_RDWR_DRIVER & driver); (+) ~PORFLOW_MESH_RDWR_DRIVER(); (CALLS PORFLOW_MESH_WRONLY_DRIVER.write()) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); }

void MEDMEMTest::testSkyLineArray ( )

Check methods (17), defined in MEDMEM_SkyLineArray.hxx: class MEDSKYLINEARRAY { (+) MEDSKYLINEARRAY(); (+) MEDSKYLINEARRAY(const MEDSKYLINEARRAY &myArray); (+) MEDSKYLINEARRAY(const int count, const int length); (+) MEDSKYLINEARRAY(const int count, const int length, const int* index, const int* value, bool shallowCopy=false); (+) ~MEDSKYLINEARRAY(); (+) inline int getNumberOf() const; (+) inline int getLength() const; (+) inline const int* getIndex() const; (+) inline const int* getValue() const; (+) inline int getNumberOfI(int i) const throw (MEDEXCEPTION); (+) inline const int* getI(int i) const throw (MEDEXCEPTION); (+) inline int getIJ(int i, int j) const throw (MEDEXCEPTION); (+) inline int getIndexValue(int i) const throw (MEDEXCEPTION); (+) inline void setIndex(const int* index); (+) inline void setI(const int i, const int* values) throw (MEDEXCEPTION); (+) inline void setIJ(int i, int j, int value) throw (MEDEXCEPTION); (+) inline void setIndexValue(int i, int value) throw (MEDEXCEPTION); (+) friend ostream& operator<<(ostream &os, const MEDSKYLINEARRAY &sky); }

References MEDMEM.MEDSKYLINEARRAY.getI(), MEDMEM.MEDSKYLINEARRAY.getIJ(), MEDMEM.MEDSKYLINEARRAY.getIndex(), MEDMEM.MEDSKYLINEARRAY.getIndexValue(), MEDMEM.MEDSKYLINEARRAY.getLength(), MEDMEM.MEDSKYLINEARRAY.getNumberOf(), MEDMEM.MEDSKYLINEARRAY.getNumberOfI(), MEDMEM.MEDSKYLINEARRAY.getValue(), medClient_test.index, MEDMEM.MEDSKYLINEARRAY.setI(), MEDMEM.MEDSKYLINEARRAY.setIJ(), MEDMEM.MEDSKYLINEARRAY.setIndex(), MEDMEM.MEDSKYLINEARRAY.setIndexValue(), and batchmode_medcorba_test.value.

void MEDMEMTest::testSTRING ( )

Check methods (not in spec), defined in MEDMEM_InterlacingPolicy.hxx:

Check methods (not in spec), defined in MEDMEM_InterlacingTraits.hxx:

Check methods (not in spec), defined in MEDMEM_MedFieldDriver.hxx:

Check methods (not in spec), defined in MEDMEM_MedMedDriver.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMchampLire.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMgaussEcr.hxx:

Check methods (not in spec), defined in MEDMEM_MEDMEMprofilEcr.hxx:

Check methods (not in spec), defined in MEDMEM_MedMeshDriver.hxx:

Check methods (not in spec), defined in MEDMEM_RCBase.hxx: class RCBASE { (reference counter presently disconnected in C++) virtual void addReference() const = 0; (reference counter presently disconnected in C++) virtual void removeReference() const = 0; }

Check methods (not in spec), defined in MEDMEM_SetInterlacingType.hxx:

Check methods (2), defined in MEDMEM_STRING.hxx: class STRING : public string { (+) STRING() (+) ~STRING() (+) operator const char * () const (+) template <class t>=""> STRING(const T &valeur) (+) template <class t>=""> STRING & operator<<(const T &valeur) }

References MEDMEMTest_createTestMesh().

void MEDMEMTest::testSupport ( )

Check methods (48), defined in MEDMEM_Support.hxx: class SUPPORT : public RCBASE { (+) SUPPORT(); (+) SUPPORT(MESH* Mesh, string Name="", MED_EN.medEntityMesh Entity=MED_ENMED_CELL); (+) SUPPORT(const SUPPORT & m); (+) virtual ~SUPPORT();

(+) friend ostream & operator<<(ostream &os,const SUPPORT &my); (+) SUPPORT& operator=(const SUPPORT &support); (+) bool operator == (const SUPPORT &support) const; (+) bool deepCompare(const SUPPORT &support) const;

(+) void update();

(+) inline void setName(string Name); (+) inline void setDescription(string Description); (+) void setMesh(MESH *Mesh) const; (+) inline void setMeshName(const string & meshName); (+) inline void setAll(bool All); (+) inline void setEntity(MED_EN.medEntityMesh Entity);

(+) inline void setNumberOfGeometricType(int NumberOfGeometricType); (+) inline void setGeometricType(const MED_EN.medGeometryElement *GeometricType); (+) inline void setNumberOfElements(const int *NumberOfElements); (+) inline void setTotalNumberOfElements(int TotalNumberOfElements); (+) inline void setNumber(MEDSKYLINEARRAY * Number); (+) inline void setNumber(const int * index, const int* value, bool shallowCopy=false);

(+) inline string getName() const; (+) inline string getDescription() const; (+) virtual inline MESH * getMesh() const; (+) string getMeshName() const; (+) inline MED_EN.medEntityMesh getEntity() const; (+) inline bool isOnAllElements() const;

(+) inline int getNumberOfTypes() const; (+) inline const MED_EN.medGeometryElement* getTypes() const; (+) inline int getNumberOfElements (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (+) inline const int * getNumberOfElements() const throw (MEDEXCEPTION); (+) virtual inline MEDSKYLINEARRAY * getnumber() const throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) virtual inline MEDSKYLINEARRAY * getnumberFromFile() const throw (MEDEXCEPTION); (+) virtual inline const int * getNumber (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) virtual inline const int * getNumberFromFile (MED_EN.medGeometryElement GeometricType) const throw (MEDEXCEPTION); (+) virtual inline const int * getNumberIndex() const throw (MEDEXCEPTION); (+) virtual int getValIndFromGlobalNumber(const int number) const throw (MEDEXCEPTION);

(+) void blending(SUPPORT * mySupport) throw (MEDEXCEPTION);

(+) void setpartial(string Description, int NumberOfGeometricType, int TotalNumberOfEntity, MED_EN.medGeometryElement *GeometricType, int *NumberOfEntity, int *NumberValue); (+) void setpartial(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION); (NO METHOD IN THIS BRANCH) void setpartial_fromfile(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION);

(+) void setProfilNames(vector<string> profilNames) throw (MEDEXCEPTION); (+) vector<string> getProfilNames() const throw (MEDEXCEPTION);

(+) void getBoundaryElements() throw (MEDEXCEPTION);

(+) void changeElementsNbs(MED_EN.medEntityMesh entity, const int *renumberingFromOldToNew, int limitNbClassicPoly, const int *renumberingFromOldToNewPoly=0); (+) void intersecting(SUPPORT * mySupport) throw (MEDEXCEPTION); (+) bool belongsTo(const SUPPORT& other, bool deepCompare=false) const;

(+) SUPPORT *getComplement() const; (+) SUPPORT *substract(const SUPPORT& other) const throw (MEDEXCEPTION);

(+) SUPPORT *getBoundaryElements(MED_EN.medEntityMesh Entity) const throw (MEDEXCEPTION);

(+) void fillFromNodeList(const list<int>& listOfNode) throw (MEDEXCEPTION); (+) void fillFromElementList(const list<int>& listOfElt) throw (MEDEXCEPTION);

(+) void clearDataOnNumbers();

(reference counter presently disconnected in C++) virtual void addReference() const; (reference counter presently disconnected in C++) virtual void removeReference() const; }

void MEDMEMTest::testTopLevel ( )

Check methods (6), defined in MEDMEM_TopLevel.hxx: (+) MED *readMedInFile(const std.string& fileName) throw(MEDEXCEPTION); (+) MESH *readMeshInFile(const std.string& fileName, const std.string& meshName); (+) template<class T> FIELD<T> *readFieldInFile (const std.string& fileName, const std.string& fieldName); (+) void writeMedToFile(const MED *medObj, const std.string& fileName); (+) void writeMeshToFile(const MESH *meshObj, const std.string& fileName); (-) template<class T> void writeFieldToFile(const FIELD<T> *fieldObj, const std.string& fileName);

References test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEMTest_createTestMesh(), test_MEDSPLITTER.meshname, NULL, MEDMEM.FIELD< T, INTERLACING_TAG >.read(), MEDMEM.readMedInFile(), MEDMEM.readMeshInFile(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.MESH.setName(), MEDMEM.writeMedToFile(), and MEDMEM.writeMeshToFile().

void MEDMEMTest::testTypeMeshDriver ( )

Check methods (not in spec), defined in MEDMEM_Tags.hxx:

Check methods (15), defined in MEDMEM_TypeMeshDriver.hxx: class TYPE_MESH_DRIVER : public GENDRIVER { (-) TYPE_MESH_DRIVER(); (-) TYPE_MESH_DRIVER(const string & fileName, MESH * ptrMesh, med_mode_acces accessMode); (-) TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver); (-) virtual ~TYPE_MESH_DRIVER(); (-) void open() throw (MEDEXCEPTION); (-) void close() throw (MEDEXCEPTION); (-) virtual void write(void) const = 0; (-) virtual void read (void) = 0; (-) void setMeshName(const string & meshName); (-) string getMeshName() const; } class TYPE_MESH_RDONLY_DRIVER : public virtual TYPE_MESH_DRIVER { (-) TYPE_MESH_RDONLY_DRIVER(); (-) TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver); (-) virtual ~TYPE_MESH_RDONLY_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); } class TYPE_MESH_WRONLY_DRIVER : public virtual TYPE_MESH_DRIVER { (-) TYPE_MESH_WRONLY_DRIVER(); (-) TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver); (-) virtual ~TYPE_MESH_WRONLY_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); } class TYPE_MESH_RDWR_DRIVER : public TYPE_MESH_RDONLY_DRIVER, public TYPE_MESH_WRONLY_DRIVER { (-) TYPE_MESH_RDWR_DRIVER(); (-) TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh); (-) TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver); (-) ~TYPE_MESH_RDWR_DRIVER(); (-) void write(void) const throw (MEDEXCEPTION); (-) void read (void) throw (MEDEXCEPTION); }

void MEDMEMTest::testUnit ( )

Check methods (18), defined in MEDMEM_Unit.hxx: class UNIT { (+) UNIT(); (+) UNIT(string Name, string Description); (+) ~UNIT(); (+) UNIT & operator=(const UNIT &unit); (+) inline void setName(string Name); (+) inline void setDescription(string Description); (+) inline void setMasse(int Masse); (+) inline void setLength(int Length); (+) inline void setTime(int Time); (+) inline void setTemperature(int Temperature); (+) inline void setMatterQuantity(int MatterQuantity); (+) void setCurrentStrength(int CurrentStrength); (+) inline void setLightIntensity(int LightIntensity);

(+) inline string getName() const; (+) inline string getDescription() const; (+) inline int getMasse() const; (+) inline int getLength() const; (+) inline int getTime() const; (+) inline int getTemperature() const; (+) inline int getMatterQuantity() const; (+) inline int getCurrentStrength() const; (+) inline int getLightIntensity() const; }

Used code of MEDMEM/tests/testUUnit.cxx

References MEDMEM.UNIT.getCurrentStrength(), MEDMEM.UNIT.getDescription(), MEDMEM.UNIT.getLength(), MEDMEM.UNIT.getLightIntensity(), MEDMEM.UNIT.getMasse(), MEDMEM.UNIT.getMatterQuantity(), MEDMEM.UNIT.getName(), MEDMEM.UNIT.getTemperature(), MEDMEM.UNIT.getTime(), MEDMEM.UNIT.setCurrentStrength(), MEDMEM.UNIT.setDescription(), MEDMEM.UNIT.setLength(), MEDMEM.UNIT.setLightIntensity(), MEDMEM.UNIT.setMasse(), MEDMEM.UNIT.setMatterQuantity(), MEDMEM.UNIT.setName(), MEDMEM.UNIT.setTemperature(), and MEDMEM.UNIT.setTime().

void MEDMEMTest::testVtkFieldDriver ( )

Check methods (14), defined in MEDMEM_VtkFieldDriver.hxx: template <class t>=""> class VTK_FIELD_DRIVER : public GENDRIVER { //MUST BE PRIVATE, because it is impossible to set _ptrField after this constructor. //AND cannot compile, so maybe it is specially implemented to prevent usage of it. (!) template <class interlacing_tag>=""> VTK_FIELD_DRIVER(); (+) template <class interlacing_tag>=""> VTK_FIELD_DRIVER (const string & fileName, FIELD<T, INTERLACING_TAG> * ptrField) (+) VTK_FIELD_DRIVER(const VTK_FIELD_DRIVER & fieldDriver) (+) ~VTK_FIELD_DRIVER() (+) void openConst() const throw (MEDEXCEPTION) (+) void openConstAppend() const throw (MEDEXCEPTION) (+) void open() throw (MEDEXCEPTION) (+) void openAppend() throw (MEDEXCEPTION) (+) void closeConst() const throw (MEDEXCEPTION) (+) void close() (+) void setFieldName(const string & fieldName); (+) string getFieldName() const; (+) void read (void) throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) void writeAppend(void) const throw (MEDEXCEPTION); }

void MEDMEMTest::testVtkMedDriver ( )

Check methods (5), defined in MEDMEM_VtkMedDriver.hxx: class VTK_MED_DRIVER : public GENDRIVER { (+) VTK_MED_DRIVER(const string & fileName, MED * const ptrMed); (+) VTK_MED_DRIVER(const VTK_MED_DRIVER & driver); (+) ~VTK_MED_DRIVER(); (+) void write (void) const; (-) virtual void read (void) {}; (+) GENDRIVER * copy (void) const; }

References MEDMEM.MED_MED_DRIVER21.close(), test_MEDSPLITTER.filename_rd, INTERP_TEST.getResourceFile(), makeTmpFile(), MEDMEM.MED_MED_DRIVER21.open(), MEDMEM.MED_MED_RDONLY_DRIVER21.read(), MEDMEMTest_TmpFilesRemover.Register(), MEDMEM.DRIVERFACTORY.setVtkBinaryFormatForWriting(), MEDMEM.MEDEXCEPTION.what(), and MEDMEM.VTK_MED_DRIVER.write().

void MEDMEMTest::testVtkMeshDriver ( )

Check methods (11), defined in MEDMEM_VtkMeshDriver.hxx: class VTK_MESH_DRIVER : public GENDRIVER { (+) VTK_MESH_DRIVER(); (+) VTK_MESH_DRIVER(const string & fileName, MESH * ptrMesh); (+) VTK_MESH_DRIVER(const VTK_MESH_DRIVER & driver); (+) ~VTK_MESH_DRIVER(); (+) void open(); (+) void close(); (+) void openConst() const throw (MEDEXCEPTION); (+) void closeConst() const throw (MEDEXCEPTION); (+) void write(void) const throw (MEDEXCEPTION); (+) void read (void) throw (MEDEXCEPTION); (+) void setMeshName(const string & meshName); (+) string getMeshName() const; }