Utilities/Testing/Validatrix.cc

Go to the documentation of this file.

#include <tst/Verify.h>
#include <tst/Validatrix.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include <fstream>

using namespace boost;
using namespace std;


namespace tst {

  namespace Validatrix {

    std::string
    BeLabel(const string& tag)
    {
      auto t = tag;
      utl::IsSpace space;
      for (auto& c : t)
        if (space(c))
          c = '_';
      return "\n" + string("t ") + t + "\n";
    }


    int
    CompareType(const char c)
    {
      switch (c) {
      case 'e': return eEqual;
      case 'a': return eAbsolute;
      case 'r': return eRelative;
      default: return -1;
      }
    }


    class Unpack {
    public:
      Unpack() { Clear(); }

      void Clear()
      { fType = -1; fCompareType = -1; fN = 0; fTolerance = -1; fItems.clear(); }

      bool Tag(const string& tag);

      bool operator==(const Unpack& u) const;

      bool operator!=(const Unpack& u) const
      { return !operator==(u); }

      size_t GetN() const { return fN; }

      void PushBack(const string& s)
      { fItems.push_back(s); }

      bool IsLabel() const
      { return fType == 't'; }

      const string& GetLabel() const
      { return IsLabel() ? fItems.front() : fgNotALabel; }

    private:
      bool Compare(const string& s1, const string& s2) const;

      template<typename T>
      bool CompareAs(const string& s1, const string& s2) const;

      template<typename T>
      bool TypeCompare(const T& t1, const T& t2) const;

      char fType;
      int fCompareType;
      size_t fN;
      double fTolerance;
      vector<string> fItems;

      static const string fgNotALabel;
    };

    const string Unpack::fgNotALabel = "not a label";


    bool
    Unpack::Tag(const string& tag)
    {
      Clear();
      if (tag.empty())
        return false;
      istringstream is(tag);
      if (!(is >> fType) ||
          !(fType == 'i' || fType == 'u' || fType == 'd' || fType == 't'))
        return false;
      if (fType == 't') {
        if (tag.size() != 1)
          return false;
        fCompareType = eEqual;
        fN = 1;
        fTolerance = 0;
        return true;
      }
      char c;
      if (!(is >> c))
        return false;
      if (c == '[') {
        if (!(is >> fN) || fN < 1)
          return false;
        if (!(is >> c) || c != ']')
          return false;
        if (!(is >> c))
          return false;
      } else
        fN = 1;
      fCompareType = CompareType(c);
      if (fCompareType == -1)
        return false;
      fTolerance = kDefaultTolerance;
      if (!(is >> c))
        return true;
      if (c != '@')
        return false;
      if (!(is >> fTolerance) || fTolerance < 0)
        return false;
      return true;
    }


    bool
    Unpack::operator==(const Unpack& u)
      const
    {
      if (fType != u.fType)
        return false;
      if (fCompareType != u.fCompareType)
        return false;
      if (fN != u.fN)
        return false;
      if (fTolerance != u.fTolerance) {
        ostringstream err;
        err << "tolerance mismatch: " << fTolerance << " != " << u.fTolerance;
        WARNING(err);
      }
      for (size_t i = 0; i < fN; ++i)
        if (!Compare(fItems[i], u.fItems[i]))
          return false;
      return true;
    }


    bool
    Unpack::Compare(const string& s1, const string& s2)
      const
    {
      switch (fType) {
      case 'i': return CompareAs<long>(s1, s2);
      case 'u': return CompareAs<unsigned long>(s1, s2);
      case 'd': return CompareAs<double>(s1, s2);
      case 't': return tst::Verify<utl::Equal>(s1, s2);
      }
      return false;
    }


    template<typename T>
    bool
    Unpack::CompareAs(const string& s1, const string& s2)
      const
    {
      const auto c1 = lexical_cast<T>(s1);
      const auto c2 = lexical_cast<T>(s2);
      return TypeCompare(c1, c2);
    }


    template<typename T>
    bool
    Unpack::TypeCompare(const T& t1, const T& t2)
      const
    {
      switch (fCompareType) {
      case eEqual:
        return tst::Verify<utl::Equal>(t1, t2);
      case eAbsolute:
        return tst::Verify<utl::CloseAbs>(t1, t2, fTolerance);
      case eRelative:
        return tst::Verify<utl::CloseRel>(t1, t2, fTolerance);
      }
      return false;
    }


    istream&
    operator>>(istream& is, Unpack& u)
    {
      u.Clear();
      string t;
      if (!(is >> t))
        return is;
      if (!u.Tag(t))
        throw utl::DoesNotComputeException("Failed to process tag!");
      const size_t n = u.GetN();
      for (size_t i = 0; i < n; ++i)
        if (is >> t)
          u.PushBack(t);
        else
          throw utl::DoesNotComputeException("Premature end of file!");
      return is;
    }


    bool
    Compare(const string& oldFilename, const string& newFilename, const bool failOnFirst)
    {
      ostringstream info;
      info << "Comparing the reference file '" << oldFilename << "' with '" << newFilename << "'";
      INFO(info);

      ifstream oldFile(oldFilename);
      if (!oldFile.is_open()) {
        ostringstream err;
        err << "File \"" << oldFilename << "\" not found!";
        ERROR(err);
        return false;
      }
      ifstream newFile(newFilename);
      if (!newFile.is_open()) {
        ostringstream err;
        err << "File \"" << newFilename << "\" not found!";
        ERROR(err);
        return false;
      }
      if (!Compare(oldFile, newFile, failOnFirst)) {
        ostringstream err;
        err << "Comparison failed!";
        ERROR(err);
        return false;
      }

      INFO("Both files are within tolerances.");

      return true;
    }


    bool
    Compare(istream& is1, istream& is2, const bool failOnFirst)
    {
      string lastLabel;
      bool ok = true;
      Unpack u1;
      Unpack u2;
      if (!(is1 >> u1) || !(is2 >> u2))
        throw utl::DoesNotComputeException("Premature end of file!");
      do {
        if (u1.IsLabel())
          lastLabel = u1.GetLabel();
        if (u1 != u2) {
          ostringstream err;
          err << "Validation failure encountered after label \""
              << lastLabel << '"';
          ERROR(err);
          if (failOnFirst)
            return false;
          else
            ok = false;
        }
        is1 >> u1;
        is2 >> u2;
      } while (is1 && is2);
      return ok && is1.eof() && is2.eof();
    }

  }

}