source: trunk/test/Suite.cc @ 1249

// $Id: Suite.cc 1249 2008-03-20 18:12:20Z peter $

/*
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://trac.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 2 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#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[])
    : ok_(true)
  {
    dev_null_ = new std::ofstream("/dev/null");
    if (argc>1 && argv[1]==std::string("-v"))
      verbose_ = true;
    else {
      verbose_ = false;
      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)
  {
    delete dev_null_;
  }


  void Suite::add(bool ok)
  {
    ok_ = ok_ && 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));
    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::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 (ok()){
      out() << "Test is ok.\n";
      return 0;
    }
    out() << "Test failed.\n";
    return -1;
  }


}}}