matfileIOTest.hh

 
#ifndef matlabmatfiletest_hh
#define matlabmatfiletest_hh
 
#include "matfile/matfileIO.hh"
#include "basics/testcase.hh"
 
namespace test {
 
  // ****************************************************** MatfileIOTest **
 
  class MatfileIOTest: public TestCase {
 
  public:
    MatfileIOTest() {};
 
    virtual ~MatfileIOTest() {
    };
 
    virtual void run();
 
  private:
 
    //##########################################################################
    //                          basic routine section
    //##########################################################################
 
    void testBasics_();
 
    //##########################################################################
    //                          add section
    //##########################################################################
 
    template<typename F>
    void testAddSth_(F& obj);
 
    template<typename F, typename G>
    void testAddSthOtherCmp_(F& obj_F, G& obj_G);
    
    //##########################################################################
    //                          get section
    //##########################################################################
 
    void testGetSth_();
 
    //##################################################################################
    //                      compare routines for all used data structures
    //##################################################################################
 
    template<class F>
    bool isEqual_(concepts::ElementMatrix<F>& m1,
                  concepts::ElementMatrix<F>& m2);
    template<class F>
    bool isEqual_(concepts::SparseMatrix<F>& m1, concepts::SparseMatrix<F>& m2);
    template<class F>
    bool isEqual_(concepts::DiagonalMatrix<F>& m1,
                  concepts::DiagonalMatrix<F>& m2);
    template<class F>
    bool isEqual_(concepts::Sequence<F>& m1, concepts::Sequence<F>& m2);
    template<class F>
    bool isEqual_(concepts::Vector<F>& m1, concepts::Vector<F>& m2);
    template<class F>
    bool isEqual_(concepts::Array<F>& m1, concepts::Array<F>& m2);
    bool isEqual_(concepts::Real& m1, concepts::Real& m2);
    bool isEqual_(concepts::Cmplx& m1, concepts::Cmplx& m2);
 
    //this is in hh file since it is not apriory clear what dims the mapping could have if there is a error
    template<class F, uint dim1, uint dim2>
    bool isEqual_(concepts::Mapping<F, dim1>& m1,
                  concepts::Mapping<F, dim2>& m2) {
      if (dim1 != dim2) {
        _fail("Dimension fails");
        return false;
      }
      for (uint i = 0; i < dim1; i++)
        for (uint j = 0; j < dim1; j++)
          if (m1(i, j) != m2(i, j)) {
            _fail("Mapping entries differ");
            return false;
          }
      return true;
    }
 
    template<class F, uint dim1, uint dim2>
    bool isEqual_(concepts::Point<F, dim1>& m1, concepts::Point<F, dim2>& m2) {
      if (dim1 != dim2) {
        _fail("Dimension fails");
        return false;
      }
      for (uint i = 0; i < dim1; i++)
        if (m1[i] != m2[i]) {
          _fail("Point entries differ");
          return false;
        }
      return true;
    }
 
    //##################################################################################
    //                        create a octave matfile to read with MatfileIO
    //##################################################################################
 
    void createMATfile() const;
 
    //##########################################################################
    //                          clear section
    //##########################################################################
 
    void testClearAll_();
 
  };
 
} // namespace test
 
#endif