CORE_Test.h

Go to the documentation of this file.

#ifndef CORE_Test_H
#define CORE_Test_H
 
#include "CORE_Object.h"
 
 
class CORE_Run;
 
//include map
#include <map>
 
//smart pointer heder
#include "sp.h"
 
//chrono header
#include "CORE_Chrono.h"
 
//Array based on valarray header
#include "CORE_StdValArray.h"
 
//Array based on pointers header
#include "CORE_StdPtrArray.h"
 
 
//Field  based on valarray hader
#include "CORE_StdValField.h"
 
 
//Field  based on  ptr header
#include "CORE_StdPtrField.h"
 
//strings list
#include "CORE_StringsList.h"
 
class CORE_Test : public virtual CORE_Object {
  
    // ATTRIBUTES
public:
  
 
private:
    
    //flag for king of test to test
    static const tFlag ALL_TESTS=0;
    static const tFlag PRIMARY_TESTS=1;
    static const tFlag ELEMENTARY_TESTS=2;
    static const tFlag CASE_TESTS=3;
 
    tString mName;
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    CORE_Test(void);
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~CORE_Test(void);   
  
  
 
public:
  
 
 
public : 
    // CREATE class
    inline static CORE_UniquePointer<CORE_Test> New() {
        CORE_UniquePointer<CORE_Test> p(new CORE_Test(),CORE_Test::Delete());
        return p;
    };
 
    //MEMORY
    //======
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
 
 
    virtual tBoolean execute(const CORE_Run& runner,
                             const std::map<tString,tString>& options) const;
    
    
    
    inline void setName(const tString& name) {
        mName=name;
    }
    inline const tString& getName() const {
        return mName;
    }
    
    virtual tBoolean primaryTests(const CORE_Run& runner,
                                  const std::map<tString,tString>& options) const;
    
    virtual tBoolean elementaryTests(const CORE_Run& runner,
                                     const std::map<tString,tString>& options) const;
    
    virtual tBoolean caseTests(const CORE_Run& runner,
                               const std::map<tString,tString>& options) const;
 
    
protected:
    virtual void getSearchingPaths(std::vector<tString>& vpaths) const {
        //package name : core within tests/<packageName>
        //5 : number of levels
        //{""} local path from the package
        getSearchingPaths("core",5,{""},vpaths);
    }
    
    tString getSearchingPathsToString() const;
    
    
    void getSearchingPaths(const tString& packageName,
                           const tUSInt& nLevels,
                           const std::vector<tString>& localPaths,
                           std::vector<tString>& vpaths) const;
 
    tString searchPath(const tString& f) const;
 
    
    tBoolean testCase(const CORE_Run& runner,const tString& name) const;
    
    virtual tBoolean compareResults(const std::map<tString,tString>& options,const tString& resultFile,const tString& referenceFile,const tReal& eps) const;
 
    
   
    template<typename T,typename Q>
    requires core_functions::isRealType<T> || core_functions::isRealType<Q>
    inline static tBoolean Equals(const T&a, const Q&b) {
        return (fabs(b-a)<std::numeric_limits<tFloat>::epsilon());
    }
    template<typename T,typename Q>
    requires core_functions::isIntegerType<T> && core_functions::isIntegerType<Q>
    inline static tBoolean Equals(const T&a, const Q&b) {
        return (a==b);
    }
   
    
private:
    tBoolean testTypes(const CORE_Run& runner,
                       const std::map<tString,tString>& options) const;
 
    tBoolean testIO(const CORE_Run& runner,
                       const std::map<tString,tString>& options) const;
 
    tBoolean testChrono(const CORE_Run& runner,
                        const std::map<tString,tString>& options) const;
 
    
 
 
    tBoolean testMemorySize(const CORE_Run& runner,
                            const std::map<tString,tString>& options);
     
    tBoolean testStringsList(const CORE_Run& runner,
                             const std::map<tString,tString>& options) const;
    tBoolean testLoops(const CORE_Run& runner,
                       const std::map<tString,tString>& options) const;
    
protected:
    
    tBoolean testArray(const CORE_Run& runner,
                       const std::map<tString,tString>& options) const;
    
    
 
    template<typename T,class I>
    tBoolean uniformRandomTest(CORE_Array<T,I>& A,CORE_Array<T,I>& B) const;
    
    tBoolean testField(const CORE_Run& runner,
                       const std::map<tString,tString>& options) const;
   
protected:
    
    template<typename Q,class I> requires core_functions::isArithmeticType<Q>
    tBoolean testArray(CORE_Array<Q,I>& A) const ;
    
 
    
    template<typename Q,typename K,K D,class S,class I>
    tBoolean testField(CORE_Field<Q,K,D,S,I>& A) const ;
 
  
 
};
 
#include "CORE_Test.hpp"
#endif