source: trunk/test/Suite.cc @ 1658

// $Id: Suite.cc 1658 2008-12-17 15:02:00Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 3 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Suite.h"
#include "environment.h"

#include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

namespace theplu {
namespace yat {
namespace test {

  Suite::Suite(int argc, char* argv[])
    : dev_null_(NULL), known_issues_(0), ok_(true)
  {
    char* buffer=std::getenv("YAT_TEST_VERBOSE");

    if ( (argc>1 && argv[1]==std::string("-v")) || 
         (buffer && buffer == std::string("1")) )
      verbose_ = true;
    else {
      verbose_ = false;
      dev_null_ = new std::ofstream("/dev/null");
      if (argc>1){
        std::stringstream ss(argv[0]);
        std::string prog;
        while(getline(ss, prog, '/'));
        if (prog.substr(0,3)=="lt-")
          prog = prog.substr(3);
        std::cout << prog << " -v : for printing extra information\n";
      }
    }
  }


  Suite::~Suite(void)
  {
    if (dev_null_)
      delete dev_null_;
  }


  bool Suite::add(bool ok)
  {
    ok_ = ok_ && ok;
    return ok;
  }


  std::string filename(const std::string& path)
  {
    return abs_srcdir()+"/"+path;
  }


  std::ostream& Suite::err(void) const
  {
    if (verbose_)
      return std::cerr;
    return *dev_null_;
  }


  bool Suite::equal(double a, double b, unsigned long int n)
  {
    double last_error_bound = n*std::numeric_limits<double>().epsilon()*
      std::min(std::abs(a), std::abs(b));
    return equal_fix(a, b, last_error_bound);
  }


  bool Suite::equal_fix(double a, double b, double margin)
  {
    // using the negated comparison to catch NaN problems
    if (!(std::abs(a-b) <= last_error_bound)){
      err() << "Error: Comparing " << a << " and " << b 
            << "\n  Difference: " << a - b
            << "\n  expected difference to be at most " << margin
            << std::endl;
      return false;
    }
    return true;
  }


  bool Suite::equal_sqrt(double a, double b, unsigned long int n)
  {
    double last_error_bound = n*
      std::sqrt(std::numeric_limits<double>().epsilon())*
      std::min(std::abs(a), std::abs(b));
    if (!(std::abs(a-b) <= last_error_bound)){
      err() << "Error: Comparing " << a << " and " << b 
            << "\n  Difference: " << a - b
            << "\n  expected difference to be at most " << last_error_bound
            << std::endl;
      return false;
    }
    return true;
  }


  bool Suite::ok(void) const
  {
    return ok_;
  }


  std::ostream& Suite::out(void) const
  {
    if (verbose_)
      return std::cout;
    return *dev_null_;
  }


  int Suite::return_value(void) const
  {
    if (known_issues_>1)
      out() << known_issues_ << " known issues were detected.\n";
    else if (known_issues_==1)
      out() << known_issues_ << " known issue was detected.\n";
    if (ok()){
      out() << "Test is ok.\n";
      return 0;
    }
    out() << "Test failed.\n";
    return -1;
  }


  bool Suite::xadd(bool ok)
  {
    if (!ok)
      ++known_issues_;
    else {
      err() << " test for a known issue returned true\n";
      add(false);
    }
    return ok;
  }


}}}