source: trunk/test/Suite.cc @ 2035

// $Id: Suite.cc 2035 2009-08-22 14:32:57Z peter $

/*
  Copyright (C) 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009 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>

#include <sys/stat.h>

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 (buffer)
      std::cerr << "WARNING: environment variable `YAT_TEST_VERBOSE' "
                << "is deprecated\n  use `VERBOSE' instead.\n";
    char* env_verbose=std::getenv("VERBOSE");

    if ( (argc>1 && argv[1]==std::string("-v")) || 
         (buffer && buffer == std::string("1")) ||
         env_verbose) {
      verbose_ = true;
      // synchronize cerr and cout, i.e., cout is flushed before
      // writing anything to cerr.
      std::cerr.tie(&std::cout);
    }
    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) <= margin)){
      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 run_as_root(void)
  {
    std::string file("write_protected_file.txt");
    std::ofstream os(file.c_str());
    os.close();
    chmod(file.c_str(), S_IRUSR);
    os.open(file.c_str());
    bool status = os.good();
    chmod(file.c_str(), S_IWUSR);
    unlink(file.c_str());
    return status;
  }


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


}}}