Validatrix.h

Go to the documentation of this file.

#ifndef _tst_Validatrix_h_
#define _tst_Validatrix_h_

#include <utl/Trace.h>
#include <utl/TimeDistribution.h>
#include <string>
#include <vector>
#include <iostream>
#include <sstream>


namespace tst {

  namespace Validatrix {

    /*
      Testing utilities
      \author Darko Veberic
      \date 13 July 2009
    */

    const double kDefaultTolerance = 1e-6;


    enum CompareType {
      eEqual = 0,
      eAbsolute = 1,
      eRelative = 2
    };


    template<typename T>
    struct Type;

    template<>
    struct Type<char> { static const char Code = 'i'; };

    template<>
    struct Type<short> { static const char Code = 'i'; };

    template<>
    struct Type<int> { static const char Code = 'i'; };

    template<>
    struct Type<long> { static const char Code = 'i'; };

    template<>
    struct Type<unsigned char> { static const char Code = 'u'; };

    template<>
    struct Type<unsigned short> { static const char Code = 'u'; };

    template<>
    struct Type<unsigned int> { static const char Code = 'u'; };

    template<>
    struct Type<unsigned long> { static const char Code = 'u'; };

    template<>
    struct Type<float> { static char const Code = 'd'; };

    template<>
    struct Type<double> { static char const Code = 'd'; };


    inline
    char
    CompareCode(const CompareType c)
    {
      const char comp[] = { 'e', 'a', 'r' };
      return comp[c];
    }


    template<typename T>
    inline
    std::string
    Pack(const std::size_t n, const T* const v, const CompareType c,
         const double tolerance = kDefaultTolerance)
    {
      if (!n)
        return "";
      std::ostringstream os;
      os << Type<T>::Code;
      if (n > 1)
        os << '[' << n << ']';
      os << CompareCode(c);
      if (c != eEqual && tolerance != kDefaultTolerance)
        os << '@' << tolerance;
      os << ' ';
      for (std::size_t i = 0; i < n; ++i)
        os << v[i] << ' ';
      return os.str();
    }


    template<typename T>
    inline std::string Pack(const T& value, const CompareType c,
                            const double tolerance = kDefaultTolerance)
    { return Pack(1, &value, c, tolerance); }


    template<typename T>
    inline std::string Pack(const utl::Trace<T>& trace, const CompareType c,
                            const double tolerance = kDefaultTolerance)
    { return Pack(trace.GetSize(), &(*trace.Begin()), c, tolerance); }


    template<typename T>
    inline std::string Pack(const std::vector<T>& vec, const CompareType c,
                            const double tolerance = kDefaultTolerance)
    { return Pack(vec.size(), &vec.front(), c, tolerance); }


    template<typename T>
    inline
    std::string
    Pack(const utl::TimeDistribution<T>& td, const CompareType c,
         const double tolerance = kDefaultTolerance)
    {
      std::string res;
      for (const auto& tv : td.SparseRange()) {
        res.append(Pack(tv.template get<0>(), eEqual));
        res.append(Pack(tv.template get<1>(), c, tolerance));
      }
      return res;
    }


    template<typename T>
    inline std::string BeEqual(const T& value)
    { return Pack(value, eEqual); }


    template<typename T>
    inline std::string BeEqual(const std::size_t n, const T* const v)
    { return Pack(n, v, eEqual); }


    template<typename T>
    inline std::string BeCloseAbs(const T& value,
                                  const double tolerance = kDefaultTolerance)
    { return Pack(value, eAbsolute, tolerance); }


    template<typename T>
    inline std::string CloseAbs(const std::size_t n, const T* const v,
                                const double tolerance = kDefaultTolerance)
    { return Pack(n, v, eAbsolute, tolerance); }


    template<typename T>
    inline std::string BeCloseRel(const T& value,
                                  const double tolerance = kDefaultTolerance)
    { return Pack(value, eRelative, tolerance); }


    template<typename T>
    inline std::string BeCloseRel(const std::size_t n, const T* const v,
                                  const double tolerance = kDefaultTolerance)
    { return Pack(n, v, eRelative, tolerance); }


    std::string BeLabel(const std::string& tag);


    bool Compare(const std::string& oldFilename, const std::string& newFilename, const bool failOnFirst = true);


    bool Compare(std::istream& s1, std::istream& s2, const bool failOnFirst = true);

  }

}


#endif